public void VisitSubqueryExpressionTest_RevisitsResult()
{
var mainFromClause = ExpressionHelper.CreateMainFromClause <Cook>();
var querModel = ExpressionHelper.CreateQueryModel(mainFromClause);
var expression = new SubQueryExpression(querModel);
var fakeSqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement())
{
TopExpression = null
};
fakeSqlStatementBuilder.Orderings.Add(new Ordering(Expression.Constant("order"), OrderingDirection.Asc));
fakeSqlStatementBuilder.SqlTables.Add(SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)));
var fakeSqlStatement = fakeSqlStatementBuilder.GetSqlStatement();
fakeSqlStatementBuilder.Orderings.Clear();
var expectedStatement = fakeSqlStatementBuilder.GetSqlStatement();
_stageMock
.Expect(mock => mock.PrepareSqlStatement(querModel, _context))
.Return(fakeSqlStatement);
var result = SqlPreparationExpressionVisitor.TranslateExpression(expression, _context, _stageMock, _methodCallTransformerProvider);
Assert.That(result, Is.TypeOf(typeof(SqlSubStatementExpression)));
Assert.That(((SqlSubStatementExpression)result).SqlStatement, Is.EqualTo(expectedStatement));
}
private SqlTable CreateSqlCompatibleSubStatementTable(
SqlStatement originalStatement,
Expression newSelectProjection,
Func <ITableInfo, SqlTable> tableCreator)
{
// create a new statement equal to the original one, but with the tuple as its select projection
var builder = new SqlStatementBuilder(originalStatement)
{
SelectProjection = newSelectProjection
};
builder.RecalculateDataInfo(originalStatement.SelectProjection);
// clear orderings unless required for TopExpression
if (originalStatement.TopExpression == null)
{
builder.Orderings.Clear();
}
var newSqlStatement = builder.GetSqlStatement();
// put new statement into a sub-statement table
var subStatementTableInfo = new ResolvedSubStatementTableInfo(_uniqueIdentifierGenerator.GetUniqueIdentifier("q"), newSqlStatement);
return(tableCreator(subStatementTableInfo));
}
public void CreateSqlTableForSubStatement_WithOrderingsAndTopExpression_AndDoNotExtractOrderingsPolicy_ReturnsTableWithOrderings_WithOriginalProjection()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
TopExpression = Expression.Constant("top"),
Orderings = { new Ordering(Expression.Constant("order1"), OrderingDirection.Asc) }
};
var statementWithOrderingsAndTopExpression = builder.GetSqlStatement();
var result = _factory.CreateSqlTableForStatement(
statementWithOrderingsAndTopExpression,
info => new SqlTable(info, JoinSemantics.Inner),
OrderingExtractionPolicy.DoNotExtractOrderings);
_stageMock.VerifyAllExpectations();
Assert.That(result.ExtractedOrderings, Is.Empty);
var tableInfo = result.SqlTable.TableInfo;
Assert.That(tableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
var subStatement = ((ResolvedSubStatementTableInfo)tableInfo).SqlStatement;
Assert.That(subStatement.Orderings, Is.Not.Empty);
Assert.That(subStatement.SelectProjection, Is.SameAs(statementWithOrderingsAndTopExpression.SelectProjection));
}
public void CreateSqlTableForSubStatement_WithOrderings_ReturnsTableWithoutOrderings_WithNewProjection()
{
var fakeSelectProjection = Expression.Constant(new KeyValuePair <Cook, KeyValuePair <string, string> > ());
_stageMock
.Expect(mock => mock.PrepareSelectExpression(Arg <Expression> .Is.Anything, Arg.Is(_context)))
.Return(fakeSelectProjection);
_stageMock.Replay();
var result = _factory.CreateSqlTableForStatement(_statementWithOrderings, info => new SqlTable(info, JoinSemantics.Inner));
_stageMock.VerifyAllExpectations();
var tableInfo = ((SqlTable)result.SqlTable).TableInfo;
Assert.That(tableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
var subStatement = ((ResolvedSubStatementTableInfo)tableInfo).SqlStatement;
Assert.That(subStatement.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo)));
Assert.That(((StreamedSequenceInfo)subStatement.DataInfo).ItemExpression, Is.SameAs(subStatement.SelectProjection));
Assert.That(((StreamedSequenceInfo)subStatement.DataInfo).DataType,
Is.SameAs(typeof(IQueryable <KeyValuePair <Cook, KeyValuePair <string, string> > >)));
var expectedSubStatementBuilder = new SqlStatementBuilder(_statementWithOrderings)
{
SelectProjection = fakeSelectProjection,
DataInfo = subStatement.DataInfo
};
expectedSubStatementBuilder.Orderings.Clear();
Assert.That(subStatement, Is.EqualTo(expectedSubStatementBuilder.GetSqlStatement()));
Assert.That(result.WhereCondition, Is.Null);
}
public void CreateSqlTableForSubStatement_WithOrderings_WithTopExpression()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
TopExpression = Expression.Constant("top"),
Orderings = { new Ordering(Expression.Constant("order1"), OrderingDirection.Asc) }
};
var statement = builder.GetSqlStatement();
var fakeSelectProjection = Expression.Constant(new KeyValuePair <Cook, string> ());
_stageMock
.Expect(mock => mock.PrepareSelectExpression(Arg <Expression> .Is.Anything, Arg <ISqlPreparationContext> .Matches(c => c == _context)))
.Return(fakeSelectProjection);
_stageMock.Replay();
var result = _factory.CreateSqlTableForStatement(statement, info => new SqlTable(info, JoinSemantics.Inner));
_stageMock.VerifyAllExpectations();
var sqlTable = (SqlTable)result.SqlTable;
Assert.That(sqlTable.TableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
Assert.That(((ResolvedSubStatementTableInfo)sqlTable.TableInfo).SqlStatement.Orderings.Count, Is.EqualTo(1));
Assert.That(result.ExtractedOrderings.Count, Is.EqualTo(1));
}
public void HandleResultOperator()
{
var resultOperator = new AnyResultOperator();
var sqlStatement = _sqlStatementBuilder.GetSqlStatement();
var fakePreparedSelectProjection = Expression.Constant(false);
_stageMock
.Expect(mock => mock.PrepareSelectExpression(Arg <Expression> .Matches(e => e is SqlExistsExpression), Arg.Is(_context)))
.WhenCalled(
mi =>
{
var selectProjection = (Expression)mi.Arguments[0];
Assert.That(selectProjection, Is.TypeOf(typeof(SqlExistsExpression)));
var expectedExistsExpression = new SqlExistsExpression(new SqlSubStatementExpression(sqlStatement));
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExistsExpression, selectProjection);
})
.Return(fakePreparedSelectProjection);
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
Assert.That(_sqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedScalarValueInfo)));
Assert.That(((StreamedScalarValueInfo)_sqlStatementBuilder.DataInfo).DataType, Is.EqualTo(typeof(Boolean)));
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.SelectProjection, Is.SameAs(fakePreparedSelectProjection));
}
public void GetStatementAndResetBuilder()
{
var statementBuilder = new SqlStatementBuilder
{
DataInfo = new TestStreamedValueInfo(typeof(Cook)),
TopExpression = ExpressionHelper.CreateExpression(),
IsDistinctQuery = true,
SelectProjection = new AggregationExpression(typeof(int), Expression.Constant(1), AggregationModifier.Min),
SqlTables = { new SqlTable(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"), JoinSemantics.Inner) },
WhereCondition = Expression.Constant(true),
RowNumberSelector = Expression.Constant("selector"),
CurrentRowNumberOffset = Expression.Constant(1),
GroupByExpression = Expression.Constant("group"),
Orderings = { new Ordering(Expression.Constant("order"), OrderingDirection.Desc) }
};
var sqlStatement = statementBuilder.GetSqlStatement();
var result = statementBuilder.GetStatementAndResetBuilder();
Assert.That(result, Is.Not.SameAs(sqlStatement));
Assert.That(result, Is.EqualTo(sqlStatement));
Assert.That(statementBuilder.DataInfo, Is.Null);
Assert.That(statementBuilder.TopExpression, Is.Null);
Assert.That(statementBuilder.IsDistinctQuery, Is.False);
Assert.That(statementBuilder.SelectProjection, Is.Null);
Assert.That(statementBuilder.SqlTables, Is.Empty);
Assert.That(statementBuilder.Orderings, Is.Empty);
Assert.That(statementBuilder.WhereCondition, Is.Null);
Assert.That(statementBuilder.RowNumberSelector, Is.Null);
Assert.That(statementBuilder.CurrentRowNumberOffset, Is.Null);
Assert.That(statementBuilder.GroupByExpression, Is.Null);
}
public void VisitSqlSubStatementExpression_WithOrderingsAndNoTopExpression()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
SelectProjection = new NamedExpression("test", Expression.Constant("test")),
Orderings = { new Ordering(Expression.Constant("order1"), OrderingDirection.Asc) }
};
var statement = builder.GetSqlStatement();
var sqlSubStatementExpression = new SqlSubStatementExpression(statement);
var stage = new DefaultSqlPreparationStage(_methodCallTransformerProvider, new ResultOperatorHandlerRegistry(), _generator);
var result = SqlPreparationFromExpressionVisitor.AnalyzeFromExpression(
sqlSubStatementExpression,
stage,
_generator,
_methodCallTransformerProvider,
_context,
info => new SqlTable(info, JoinSemantics.Inner));
var sqlTable = (SqlTable)result.SqlTable;
Assert.That(sqlTable.TableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
Assert.That(((ResolvedSubStatementTableInfo)sqlTable.TableInfo).SqlStatement.Orderings.Count, Is.EqualTo(0));
}
public void VisitSubqueryExpressionTest_IsCountQuery()
{
var mainFromClause = ExpressionHelper.CreateMainFromClause <Cook>();
var querModel = ExpressionHelper.CreateQueryModel(mainFromClause);
var expression = new SubQueryExpression(querModel);
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement();
var fakeSqlStatementBuilder = new SqlStatementBuilder(sqlStatement)
{
SelectProjection =
new AggregationExpression(typeof(int), sqlStatement.SelectProjection, AggregationModifier.Count)
};
var fakeSqlStatement = fakeSqlStatementBuilder.GetSqlStatement();
_stageMock
.Expect(mock => mock.PrepareSqlStatement(querModel, _context))
.Return(fakeSqlStatement);
var result = SqlPreparationExpressionVisitor.TranslateExpression(expression, _context, _stageMock, _methodCallTransformerProvider);
Assert.That(result, Is.TypeOf(typeof(SqlSubStatementExpression)));
Assert.That(((SqlSubStatementExpression)result).SqlStatement, Is.SameAs(fakeSqlStatement));
Assert.That(
((AggregationExpression)((SqlSubStatementExpression)result).SqlStatement.SelectProjection).AggregationModifier,
Is.EqualTo(AggregationModifier.Count));
}
public void VisitSqlSubStatmentExpression_HasTopExpression_ReturnsNew()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook());
builder.Orderings.Add(new Ordering(Expression.Constant("order"), OrderingDirection.Asc));
var sqlStatement = builder.GetSqlStatement();
builder.Orderings.Clear();
var expectedStatement = builder.GetSqlStatement();
var subStatementExpression = new SqlSubStatementExpression(sqlStatement);
var result = SqlPreparationExpressionVisitor.TranslateExpression(subStatementExpression, _context, _stageMock, _methodCallTransformerProvider);
Assert.That(result, Is.Not.SameAs(subStatementExpression));
Assert.That(result, Is.TypeOf(typeof(SqlSubStatementExpression)));
Assert.That(((SqlSubStatementExpression)result).SqlStatement, Is.EqualTo(expectedStatement));
}
protected virtual SqlStatement ResolveSqlStatement(SqlStatement sqlStatement)
{
ArgumentUtility.CheckNotNull("sqlStatement", sqlStatement);
foreach (var sqlTable in sqlStatement.SqlTables)
{
sqlTable.Accept(this);
}
var sqlStatementBuilder = new SqlStatementBuilder(sqlStatement);
var previousSelectProjection = sqlStatementBuilder.SelectProjection;
sqlStatementBuilder.SelectProjection = ResolveSelectProjection(sqlStatementBuilder.SelectProjection, sqlStatementBuilder);
sqlStatementBuilder.RecalculateDataInfo(previousSelectProjection);
if (sqlStatementBuilder.GroupByExpression != null)
{
sqlStatementBuilder.GroupByExpression = ResolveGroupByExpression(sqlStatementBuilder.GroupByExpression);
}
if (sqlStatementBuilder.WhereCondition != null)
{
sqlStatementBuilder.WhereCondition = ResolveWhereCondition(sqlStatementBuilder.WhereCondition);
}
if (sqlStatementBuilder.TopExpression != null)
{
sqlStatementBuilder.TopExpression = ResolveTopExpression(sqlStatementBuilder.TopExpression);
}
if (sqlStatementBuilder.Orderings.Count > 0)
{
for (int i = 0; i < sqlStatementBuilder.Orderings.Count; ++i)
{
var resolvedOrderingExpression = _stage.ResolveOrderingExpression(sqlStatementBuilder.Orderings[i].Expression, _context);
if (resolvedOrderingExpression != sqlStatementBuilder.Orderings[i].Expression)
{
sqlStatementBuilder.Orderings[i] = new Ordering(resolvedOrderingExpression, sqlStatementBuilder.Orderings[i].OrderingDirection);
}
}
}
for (int i = 0; i < sqlStatement.SetOperationCombinedStatements.Count; i++)
{
var combinedStatement = sqlStatement.SetOperationCombinedStatements[i];
var resolvedSqlStatement = _stage.ResolveSqlStatement(combinedStatement.SqlStatement, _context);
if (!Equals(resolvedSqlStatement, combinedStatement.SqlStatement))
{
sqlStatementBuilder.SetOperationCombinedStatements[i] = new SetOperationCombinedStatement(
resolvedSqlStatement,
combinedStatement.SetOperation);
}
}
return(sqlStatementBuilder.GetSqlStatement());
}
public void IsSimplifiableGroupAggregate_False_TooManySqlTables()
{
var sqlStatementBuilder = new SqlStatementBuilder(_simplifiableResolvedSqlStatement);
sqlStatementBuilder.SqlTables.Add(SqlStatementModelObjectMother.CreateSqlTable());
var sqlStatement = sqlStatementBuilder.GetSqlStatement();
Assert.That(_groupAggregateSimplifier.IsSimplifiableGroupAggregate(sqlStatement), Is.False);
}
public void HandleResultOperator_GroupByAfterTopExpression()
{
var topExpression = Expression.Constant("top");
_sqlStatementBuilder.TopExpression = topExpression;
var keySelector = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false);
var elementSelector = Expression.Constant("elementSelector");
var resultOperator = new GroupResultOperator("itemName", keySelector, elementSelector);
var originalStatement = _sqlStatementBuilder.GetSqlStatement();
var originalDataInfo = _sqlStatementBuilder.DataInfo;
var fakeFromExpressionInfo = new FromExpressionInfo(
new SqlTable(new ResolvedSubStatementTableInfo("sc", originalStatement), JoinSemantics.Inner), new Ordering[0], elementSelector, null);
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(keySelector, _context))
.Return(keySelector);
_stageMock
.Expect(mock => mock.PrepareResultOperatorItemExpression(elementSelector, _context))
.Return(elementSelector);
_stageMock
.Expect(
mock => mock.PrepareFromExpression(Arg <Expression> .Is.Anything, Arg.Is(_context), Arg <Func <ITableInfo, SqlTable> > .Is.Anything))
.Return(fakeFromExpressionInfo)
.WhenCalled(mi =>
{
var fromExpression = (Expression)mi.Arguments[0];
CheckExpressionMovedIntoSubStatement(fromExpression, originalStatement);
});
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.GroupByExpression, Is.SameAs(keySelector));
Assert.That(_sqlStatementBuilder.SqlTables.Count, Is.EqualTo(1));
Assert.That(_sqlStatementBuilder.SqlTables[0], Is.SameAs(fakeFromExpressionInfo.SqlTable));
Assert.That(_sqlStatementBuilder.DataInfo, Is.Not.SameAs(originalDataInfo));
Assert.That(
_sqlStatementBuilder.DataInfo.DataType,
Is.EqualTo(typeof(IQueryable <>).MakeGenericType(typeof(IGrouping <,>).MakeGenericType(typeof(string), typeof(string)))));
}
public void ResolveSqlStatement()
{
var constantExpression = Expression.Constant(new Restaurant());
var whereCondition = Expression.Constant(true);
var topExpression = Expression.Constant("top");
var groupExpression = Expression.Constant("group");
var ordering = new Ordering(Expression.Constant("ordering"), OrderingDirection.Desc);
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook)))
{
SelectProjection = constantExpression,
DataInfo = new StreamedSequenceInfo(typeof(Restaurant[]), constantExpression),
WhereCondition = whereCondition,
GroupByExpression = groupExpression,
TopExpression = topExpression,
};
builder.Orderings.Add(ordering);
var sqlStatement = builder.GetSqlStatement();
var fakeExpression = Expression.Constant(new Cook());
var fakeWhereCondition = Expression.Constant(true);
var fakeGroupExpression = Expression.Constant("group");
var fakeTopExpression = Expression.Constant("top");
var fakeOrderExpression = Expression.Constant("order");
_stageMock
.Expect(mock => mock.ResolveSelectExpression(Arg.Is(constantExpression), Arg <SqlStatementBuilder> .Is.Anything, Arg.Is(_mappingResolutionContext)))
.Return(fakeExpression);
_stageMock
.Expect(mock => mock.ResolveWhereExpression(whereCondition, _mappingResolutionContext))
.Return(fakeWhereCondition);
_stageMock
.Expect(mock => mock.ResolveGroupByExpression(groupExpression, _mappingResolutionContext))
.Return(fakeGroupExpression);
_stageMock
.Expect(mock => mock.ResolveTopExpression(topExpression, _mappingResolutionContext))
.Return(fakeTopExpression);
_stageMock
.Expect(mock => mock.ResolveOrderingExpression(ordering.Expression, _mappingResolutionContext))
.Return(fakeOrderExpression);
_stageMock
.Expect(mock => mock.ResolveTableInfo(((SqlTable)sqlStatement.SqlTables[0]).TableInfo, _mappingResolutionContext))
.Return(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"));
_stageMock.Replay();
var resolveSqlStatement = _visitor.ResolveSqlStatement(sqlStatement);
_stageMock.VerifyAllExpectations();
Assert.That(resolveSqlStatement.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo)));
Assert.That(((StreamedSequenceInfo)resolveSqlStatement.DataInfo).DataType, Is.EqualTo(typeof(IQueryable <>).MakeGenericType(typeof(Cook))));
Assert.That(resolveSqlStatement.SelectProjection, Is.SameAs(fakeExpression));
Assert.That(resolveSqlStatement.WhereCondition, Is.SameAs(fakeWhereCondition));
Assert.That(resolveSqlStatement.TopExpression, Is.SameAs(fakeTopExpression));
Assert.That(resolveSqlStatement.GroupByExpression, Is.SameAs(fakeGroupExpression));
Assert.That(resolveSqlStatement.Orderings[0].Expression, Is.SameAs(fakeOrderExpression));
Assert.That(sqlStatement.Orderings[0].Expression, Is.SameAs(ordering.Expression));
}
public void CreateExpression_WithSqlTables()
{
var sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement());
var sqlStatement = sqlStatementBuilder.GetSqlStatement();
var result = sqlStatement.CreateExpression();
Assert.That(result, Is.TypeOf(typeof(SqlSubStatementExpression)));
Assert.That(((SqlSubStatementExpression)result).SqlStatement, Is.SameAs(sqlStatement));
}
public void GetSqlStatement_NoSelectProjection()
{
var statementBuilder = new SqlStatementBuilder();
statementBuilder.DataInfo = new TestStreamedValueInfo(typeof(int));
statementBuilder.SelectProjection = null;
Assert.That(
() => statementBuilder.GetSqlStatement(),
Throws.InvalidOperationException.With.Message.EqualTo("A SelectProjection must be set before the SqlStatement can be retrieved."));
}
public void GetSqlStatement_NoDataInfoSet()
{
var statementBuilder = new SqlStatementBuilder();
statementBuilder.DataInfo = null;
statementBuilder.SelectProjection = ExpressionHelper.CreateExpression();
Assert.That(
() => statementBuilder.GetSqlStatement(),
Throws.InvalidOperationException.With.Message.EqualTo("A DataInfo must be set before the SqlStatement can be retrieved."));
}
public virtual SqlStatement PrepareSqlStatement(QueryModel queryModel, ISqlPreparationContext context)
{
var builder = new SqlStatementBuilder
{
DataInfo = new StreamedScalarValueInfo(typeof(string)),
SelectProjection = Expression.Constant("Value added by preparation mixin")
};
return(builder.GetSqlStatement());
}
public void IsSimplifiableGroupAggregate_False_NoResolvedJoinedGroupingTableInfo()
{
var sqlStatementBuilder = new SqlStatementBuilder(_simplifiableResolvedSqlStatement);
sqlStatementBuilder.SqlTables.Clear();
sqlStatementBuilder.SqlTables.Add(SqlStatementModelObjectMother.CreateSqlTable(new ResolvedSimpleTableInfo(typeof(int), "table", "t0")));
var sqlStatement = sqlStatementBuilder.GetSqlStatement();
Assert.That(_groupAggregateSimplifier.IsSimplifiableGroupAggregate(sqlStatement), Is.False);
}
public void CreateExpression_WithNoSqlTablesAndNoDistinctQueryAndNoAggregationModifier()
{
var sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement());
sqlStatementBuilder.SqlTables.Clear();
var sqlStatement = sqlStatementBuilder.GetSqlStatement();
var result = sqlStatement.CreateExpression();
Assert.That(result, Is.SameAs(sqlStatement.SelectProjection));
}
public void HandleResultOperator()
{
var predicate = Expression.Constant(true);
var preparedPredicate = Expression.Constant(false);
var resultOperator = new AllResultOperator(predicate);
var sqlStatement = _sqlStatementBuilder.GetSqlStatement();
var fakePreparedSelectProjection = Expression.Constant(false);
_stageMock
.Expect(mock => mock.PrepareWhereExpression(
Arg <Expression> .Matches(e => e.NodeType == ExpressionType.Not && (((UnaryExpression)e).Operand == predicate)),
Arg <ISqlPreparationContext> .Matches(c => c == _context)))
.Return(preparedPredicate);
_stageMock
.Expect(mock => mock.PrepareSelectExpression(Arg <Expression> .Matches(e => e.NodeType == ExpressionType.Not), Arg.Is(_context)))
.WhenCalled(
mi =>
{
var selectProjection = (Expression)mi.Arguments[0];
var expectedSubStatement = new SqlStatementBuilder(sqlStatement)
{
WhereCondition = preparedPredicate
}.GetSqlStatement();
var expectedExistsExpression = new SqlExistsExpression(new SqlSubStatementExpression(expectedSubStatement));
var expectedExpression = Expression.Not(expectedExistsExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, selectProjection);
})
.Return(fakePreparedSelectProjection);
_stageMock.Replay();
_handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context);
_stageMock.VerifyAllExpectations();
Assert.That(_sqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedScalarValueInfo)));
Assert.That(((StreamedScalarValueInfo)_sqlStatementBuilder.DataInfo).DataType, Is.EqualTo(typeof(Boolean)));
Assert.That(_sqlStatementBuilder.SelectProjection, Is.SameAs(fakePreparedSelectProjection));
}
public static SqlStatement CreateMinimalSqlStatement(SqlStatementBuilder builder)
{
if (builder.SelectProjection == null)
{
builder.SelectProjection = ExpressionHelper.CreateExpression();
}
if (builder.DataInfo == null)
{
builder.DataInfo = new TestStreamedValueInfo(builder.SelectProjection.Type);
}
return(builder.GetSqlStatement());
}
public virtual Expression VisitSqlSubStatement(SqlSubStatementExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
if (expression.SqlStatement.Orderings.Count > 0 && expression.SqlStatement.TopExpression == null)
{
var builder = new SqlStatementBuilder(expression.SqlStatement);
builder.Orderings.Clear();
return(new SqlSubStatementExpression(builder.GetSqlStatement()));
}
return(expression);
}
public void VisitSqlSubStatmentExpression_NoTopExpression_ReturnsSame()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook());
builder.Orderings.Clear();
var sqlStatement = builder.GetSqlStatement();
var subStatementExpression = new SqlSubStatementExpression(sqlStatement);
var result = SqlPreparationExpressionVisitor.TranslateExpression(subStatementExpression, _context, _stageMock, _methodCallTransformerProvider);
Assert.That(result, Is.SameAs(subStatementExpression));
}
public void CreateExpression_IsDistinctQuery()
{
var sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement());
sqlStatementBuilder.SqlTables.Clear();
sqlStatementBuilder.IsDistinctQuery = true;
var sqlStatement = sqlStatementBuilder.GetSqlStatement();
var result = sqlStatement.CreateExpression();
Assert.That(result, Is.TypeOf(typeof(SqlSubStatementExpression)));
Assert.That(((SqlSubStatementExpression)result).SqlStatement, Is.SameAs(sqlStatement));
}
public void ResolveSqlStatement_WithNoChanges_ShouldLeaveAllObjectsTheSame()
{
var constantExpression = Expression.Constant(new Restaurant());
var whereCondition = Expression.Constant(true);
var topExpression = Expression.Constant("top");
var groupExpression = Expression.Constant("group");
var ordering = new Ordering(Expression.Constant("ordering"), OrderingDirection.Desc);
var setOperationCombinedStatement = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement();
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook)))
{
SelectProjection = constantExpression,
DataInfo = new StreamedSequenceInfo(typeof(Restaurant[]), constantExpression),
WhereCondition = whereCondition,
GroupByExpression = groupExpression,
TopExpression = topExpression,
SetOperationCombinedStatements = { setOperationCombinedStatement }
};
builder.Orderings.Add(ordering);
var sqlStatement = builder.GetSqlStatement();
_stageMock
.Expect(mock => mock.ResolveSelectExpression(Arg.Is(constantExpression), Arg <SqlStatementBuilder> .Is.Anything, Arg.Is(_mappingResolutionContext)))
.Return(constantExpression);
_stageMock
.Expect(mock => mock.ResolveWhereExpression(whereCondition, _mappingResolutionContext))
.Return(whereCondition);
_stageMock
.Expect(mock => mock.ResolveGroupByExpression(groupExpression, _mappingResolutionContext))
.Return(groupExpression);
_stageMock
.Expect(mock => mock.ResolveTopExpression(topExpression, _mappingResolutionContext))
.Return(topExpression);
_stageMock
.Expect(mock => mock.ResolveOrderingExpression(ordering.Expression, _mappingResolutionContext))
.Return(ordering.Expression);
_stageMock
.Expect(mock => mock.ResolveTableInfo(sqlStatement.SqlTables[0].TableInfo, _mappingResolutionContext))
.Return((IResolvedTableInfo)sqlStatement.SqlTables[0].TableInfo);
_stageMock
.Expect(mock => mock.ResolveSqlStatement(setOperationCombinedStatement.SqlStatement, _mappingResolutionContext))
.Return(setOperationCombinedStatement.SqlStatement);
_stageMock.Replay();
var resolvedSqlStatement = _visitor.ResolveSqlStatement(sqlStatement);
_stageMock.VerifyAllExpectations();
Assert.That(resolvedSqlStatement, Is.EqualTo(sqlStatement));
}
public virtual SqlStatement ResolveSqlStatement(SqlStatement sqlStatement, IMappingResolutionContext context)
{
Assert.That(sqlStatement.SelectProjection, Is.TypeOf(typeof(ConstantExpression)));
Assert.That(((ConstantExpression)sqlStatement.SelectProjection).Value, Is.EqualTo("Value added by preparation mixin"));
var builder = new SqlStatementBuilder
{
DataInfo = new StreamedScalarValueInfo(typeof(string)),
SelectProjection =
new SqlEntityDefinitionExpression(typeof(int), "c", "CookTable", e => e.GetColumn(typeof(int), "ID", false))
};
return(builder.GetSqlStatement());
}
public ITableInfo VisitUnresolvedGroupReferenceTableInfo(UnresolvedGroupReferenceTableInfo tableInfo)
{
var groupSourceSubStatementTableInfo = tableInfo.ReferencedGroupSource.GetResolvedTableInfo() as ResolvedSubStatementTableInfo;
if (groupSourceSubStatementTableInfo == null)
{
var message = string.Format(
"This SQL generator only supports sequences in from expressions if they are members of an entity or if they come from a GroupBy operator. "
+ "Sequence: '{0}'", tableInfo);
throw new NotSupportedException(message);
}
var groupingSelectExpression = groupSourceSubStatementTableInfo.SqlStatement.SelectProjection as SqlGroupingSelectExpression;
if (groupingSelectExpression == null)
{
throw new NotSupportedException(
"When a sequence retrieved by a subquery is used in a from expression, the subquery must end with a GroupBy operator.");
}
var elementSelectingStatementBuilder = new SqlStatementBuilder(groupSourceSubStatementTableInfo.SqlStatement)
{
GroupByExpression = null
};
var currentKeyExpression = Expression.MakeMemberAccess(
new SqlTableReferenceExpression(tableInfo.ReferencedGroupSource),
groupingSelectExpression.Type.GetProperty("Key"));
var groupKeyJoinCondition = _stage.ResolveWhereExpression(
Expression.OrElse(
Expression.AndAlso(new SqlIsNullExpression(groupingSelectExpression.KeyExpression), new SqlIsNullExpression(currentKeyExpression)),
Expression.AndAlso(
Expression.AndAlso(
new SqlIsNotNullExpression(groupingSelectExpression.KeyExpression),
new SqlIsNotNullExpression(currentKeyExpression)),
Expression.Equal(groupingSelectExpression.KeyExpression, currentKeyExpression))),
_context);
elementSelectingStatementBuilder.AddWhereCondition(groupKeyJoinCondition);
elementSelectingStatementBuilder.SelectProjection = groupingSelectExpression.ElementExpression;
elementSelectingStatementBuilder.RecalculateDataInfo(groupingSelectExpression);
return(new ResolvedJoinedGroupingTableInfo(
_generator.GetUniqueIdentifier("q"),
elementSelectingStatementBuilder.GetSqlStatement(),
groupingSelectExpression,
groupSourceSubStatementTableInfo.TableAlias));
}
public void CreateExpression_HasAggregationModifier()
{
var sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement());
sqlStatementBuilder.SqlTables.Clear();
var selectProjection = new AggregationExpression(typeof(double), sqlStatementBuilder.SelectProjection, AggregationModifier.Max);
sqlStatementBuilder.SelectProjection = selectProjection;
var sqlStatement = sqlStatementBuilder.GetSqlStatement();
var result = sqlStatement.CreateExpression();
Assert.That(result, Is.SameAs(selectProjection));
}
private Expression CheckAndSimplifyEntityWithinSubStatement(SqlSubStatementExpression sqlSubStatementExpression)
{
var newSelectProjection = ResolvePotentialEntity(sqlSubStatementExpression.SqlStatement.SelectProjection);
if (newSelectProjection != sqlSubStatementExpression.SqlStatement.SelectProjection)
{
var newSubStatement = new SqlStatementBuilder(sqlSubStatementExpression.SqlStatement)
{
SelectProjection = newSelectProjection
};
newSubStatement.RecalculateDataInfo(sqlSubStatementExpression.SqlStatement.SelectProjection);
return(newSubStatement.GetSqlStatement().CreateExpression());
}
return(sqlSubStatementExpression);
}