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 VisitSqlSubStatementExpression_WithChanges() { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(Expression.Constant(0)); var expression = new SqlSubStatementExpression(sqlStatement); var fakeResolvedStatement = SqlStatementModelObjectMother.CreateSqlStatement(Expression.Constant(1)); _stageMock .Expect(mock => mock.ResolveSqlStatement(sqlStatement, _mappingResolutionContext)) .Return(fakeResolvedStatement); var fakeSimplifiedExpression = Expression.Constant(0); _groupAggregateSimplifierMock .Expect( mock => mock.SimplifyIfPossible( Arg <SqlSubStatementExpression> .Matches(e => ReferenceEquals(e.SqlStatement, fakeResolvedStatement)), Arg.Is(expression.SqlStatement.SelectProjection))) .Return(fakeSimplifiedExpression); var result = _visitor.Visit(expression); _stageMock.VerifyAllExpectations(); _groupAggregateSimplifierMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(fakeSimplifiedExpression)); }
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)); }
public void HandleResultOperator() { var resultOperator = new UnionResultOperator("x", typeof(int), ExpressionHelper.CreateExpression(typeof(int[]))); var preparedSource2Statement = SqlStatementModelObjectMother.CreateSqlStatement(); var preparedSource2Expression = new SqlSubStatementExpression(preparedSource2Statement); _stageMock .Expect(mock => mock.PrepareResultOperatorItemExpression(resultOperator.Source2, _context)) .Return(preparedSource2Expression); _handler.HandleResultOperator(resultOperator, _sqlStatementBuilder, UniqueIdentifierGenerator, _stageMock, _context); _stageMock.VerifyAllExpectations(); // Main functionality Assert.That(_sqlStatementBuilder.SetOperationCombinedStatements, Has.Count.EqualTo(1)); Assert.That(_sqlStatementBuilder.SetOperationCombinedStatements[0].SetOperation, Is.EqualTo(SetOperation.Union)); Assert.That(_sqlStatementBuilder.SetOperationCombinedStatements[0].SqlStatement, Is.SameAs(preparedSource2Statement)); // Data info Assert.That(_sqlStatementBuilder.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo))); Assert.That(((StreamedSequenceInfo)_sqlStatementBuilder.DataInfo).DataType, Is.EqualTo(typeof(IQueryable <>).MakeGenericType(typeof(int)))); Assert.That( ((StreamedSequenceInfo)_sqlStatementBuilder.DataInfo).ItemExpression, Is.EqualTo(new QuerySourceReferenceExpression(resultOperator))); // Everyone referencing the result operator should reference the (outer) select projection instead. Assert.That( _context.GetExpressionMapping(new QuerySourceReferenceExpression(resultOperator)), Is.SameAs(_sqlStatementBuilder.SelectProjection)); }
public void VisitMemberExpression_WithInnerSqlSubStatementExpression() { var selectProjection = Expression.Constant(new Cook()); var fakeStatement = SqlStatementModelObjectMother.CreateSqlStatement( new NamedExpression("test", selectProjection), new SqlTable(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"), JoinSemantics.Left)); var memberInfo = typeof(Cook).GetProperty("Name"); var queryModel = ExpressionHelper.CreateQueryModel <Cook>(); queryModel.ResultOperators.Add(new FirstResultOperator(false)); var expression = new SubQueryExpression(queryModel); var memberExpression = Expression.MakeMemberAccess(expression, memberInfo); _stageMock .Expect(mock => mock.PrepareSqlStatement(queryModel, _context)) .Return(fakeStatement); _stageMock.Replay(); var result = SqlPreparationExpressionVisitor.TranslateExpression(memberExpression, _context, _stageMock, _methodCallTransformerProvider); _stageMock.VerifyAllExpectations(); Assert.That(result, Is.TypeOf(typeof(SqlSubStatementExpression))); var expectedSelectProjection = new NamedExpression("test", Expression.MakeMemberAccess(selectProjection, memberInfo)); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedSelectProjection, ((SqlSubStatementExpression)result).SqlStatement.SelectProjection); Assert.That(((SqlSubStatementExpression)result).SqlStatement.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo))); Assert.That(((SqlSubStatementExpression)result).SqlStatement.DataInfo.DataType, Is.EqualTo(typeof(IQueryable <>).MakeGenericType(typeof(string)))); }
public void ResolveTableInfo_GroupReferenceTableInfo_NoGorupingSubStatement() { var subStatement = SqlStatementModelObjectMother.CreateSqlStatement(Expression.Constant(new int[0])); var groupSource = SqlStatementModelObjectMother.CreateSqlTable(new ResolvedSubStatementTableInfo("q0", subStatement)); var tableInfo = new UnresolvedGroupReferenceTableInfo(groupSource); ResolvingTableInfoVisitor.ResolveTableInfo(tableInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext); }
public void ResolvePotentialEntity_Substatement_WithoutEntity_ReturnsSameExpression() { var subStatement = SqlStatementModelObjectMother.CreateSqlStatement(Expression.Constant(0)); var subStatementExpression = new SqlSubStatementExpression(subStatement); var result = _entityIdentityResolver.ResolvePotentialEntity(subStatementExpression); Assert.That(result, Is.SameAs(subStatementExpression)); }
private SqlStatementBuilder CreateSqlStatementBuilder(Type sequenceItemType) { var selectProjection = ExpressionHelper.CreateExpression(sequenceItemType); return(new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement()) { DataInfo = new StreamedSequenceInfo(sequenceItemType.MakeArrayType(), selectProjection), SelectProjection = selectProjection }); }
public void GenerateTextForSqlStatement() { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement( _entityExpression, new[] { new SqlTable(new ResolvedSimpleTableInfo(typeof(int), "Table", "t"), JoinSemantics.Inner) }); var stage = new DefaultSqlGenerationStage(); stage.GenerateTextForSqlStatement(_commandBuilder, sqlStatement); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("SELECT [t].[ID],[t].[Name],[t].[City] FROM [Table] AS [t]")); }
public void SetUp() { _stageMock = MockRepository.GenerateMock <ISqlPreparationStage> (); _generator = new UniqueIdentifierGenerator(); _handler = new CastResultOperatorHandler(); _sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement()) { DataInfo = new StreamedSequenceInfo(typeof(Cook[]), Expression.Constant(new Cook())) }; _context = SqlStatementModelObjectMother.CreateSqlPreparationContext(); }
public void SetUp() { _generator = new UniqueIdentifierGenerator(); _stage = new DefaultSqlPreparationStage(new CompoundMethodCallTransformerProvider(), new ResultOperatorHandlerRegistry(), _generator); _handler = new SumResultOperatorHandler(); _sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement()) { DataInfo = new StreamedSequenceInfo(typeof(int[]), Expression.Constant(5)) }; _context = SqlStatementModelObjectMother.CreateSqlPreparationContext(); }
public void ResolvePotentialEntity_Substatement_WithEntity_TrivialProjection_ResolvesToIdentityDirectly() { // No SQL tables => the substatement can be completely eliminated. var subStatement = SqlStatementModelObjectMother.CreateSqlStatement(_entityExpression); var subStatementExpression = new SqlSubStatementExpression(subStatement); var result = _entityIdentityResolver.ResolvePotentialEntity(subStatementExpression); var expectedSelectProjection = _entityExpression.GetIdentityExpression(); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedSelectProjection, result); }
public override void SetUp() { base.SetUp(); _stage = CreateDefaultSqlPreparationStage(); _handler = new TakeResultOperatorHandler(); _sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement()) { DataInfo = new StreamedSequenceInfo(typeof(Cook[]), Expression.Constant(new Cook())) }; _context = SqlStatementModelObjectMother.CreateSqlPreparationContext(); }
public override void SetUp() { base.SetUp(); _stage = CreateDefaultSqlPreparationStage(); _handler = new TestableAggregationResultOperatorHandler(); _sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement()) { DataInfo = new StreamedSequenceInfo(typeof(int[]), Expression.Constant(5)), SelectProjection = new NamedExpression(null, Expression.Constant(0)) }; _context = SqlStatementModelObjectMother.CreateSqlPreparationContext(); }
public void ResolvePotentialEntity_Substatement_StripsConversions() { var subStatement = SqlStatementModelObjectMother.CreateSqlStatement(Expression.Convert(_entityExpression, typeof(object)), SqlStatementModelObjectMother.CreateSqlTable()); var subStatementExpression = new SqlSubStatementExpression(subStatement); var result = _entityIdentityResolver.ResolvePotentialEntity(Expression.Convert(subStatementExpression, typeof(object))); Assert.That(result, Is.TypeOf <SqlSubStatementExpression> ()); var expectedSelectProjection = _entityExpression.GetIdentityExpression(); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedSelectProjection, ((SqlSubStatementExpression)result).SqlStatement.SelectProjection); Assert.That(((SqlSubStatementExpression)result).SqlStatement.DataInfo.DataType, Is.SameAs(typeof(IQueryable <int>))); }
public void ResolveSubStatementReferenceExpression_CopiesExpression_ForUnknownExpression() { var referencedExpression = Expression.Constant(0); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(referencedExpression); var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement); var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression( referencedExpression, tableInfo, sqlTable, _context); Assert.That(result, Is.SameAs(referencedExpression)); }
public void BuildSelectPart_WithSelect() { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(); _stageMock.Expect( mock => mock.GenerateTextForSelectExpression(_commandBuilder, sqlStatement.SelectProjection)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("[t].[ID],[t].[Name],[t].[City]")); _stageMock.Replay(); _generator.BuildSelectPart(sqlStatement, _commandBuilder, false); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("SELECT [t].[ID],[t].[Name],[t].[City]")); _stageMock.VerifyAllExpectations(); }
public void ResolveSubStatementReferenceExpression_CreatesColumnExpression_ForNamedExpression() { var referencedExpression = new NamedExpression("test", Expression.Constant(0)); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(referencedExpression); var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement); var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression( referencedExpression, tableInfo, sqlTable, _context); var expectedResult = new SqlColumnDefinitionExpression(typeof(int), "q0", "test", false); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result); }
public void BuildSelectPart_OuterSelect_NoSetOperationsAggregation() { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(); _stageMock.Expect( mock => mock.GenerateTextForOuterSelectExpression( _commandBuilder, sqlStatement.SelectProjection, SetOperationsMode.StatementIsNotSetCombined) ); _generator.BuildSelectPart(sqlStatement, _commandBuilder, true); _stageMock.VerifyAllExpectations(); }
public void ResolveSubStatementReferenceExpression_RegistersEntityTable_WithinUnknownExpression() { var referencedExpression = Expression.Convert(SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)), typeof(Chef)); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(referencedExpression); var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement); var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression( referencedExpression, tableInfo, sqlTable, _context); Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Convert)); var entityReference = (SqlEntityExpression)((UnaryExpression)result).Operand; Assert.That(_context.GetSqlTableForEntityExpression(entityReference), Is.SameAs(sqlTable)); }
public void BuildSetOperationCombinedStatementsPart_UnionAll() { var setOperationCombinedStatement = new SetOperationCombinedStatement(SqlStatementModelObjectMother.CreateSqlStatement(), SetOperation.UnionAll); var sqlStatement = SqlStatementModelObjectMother.CreateMinimalSqlStatement( new SqlStatementBuilder { SetOperationCombinedStatements = { setOperationCombinedStatement } }); _stageMock.Expect(mock => mock.GenerateTextForSqlStatement(_commandBuilder, setOperationCombinedStatement.SqlStatement)) .WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("statement")); _stageMock.Replay(); _generator.BuildSetOperationCombinedStatementsPart(sqlStatement, _commandBuilder); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo(" UNION ALL (statement)")); _stageMock.VerifyAllExpectations(); }
public void VisitSqlSubStatementExpression_NoChanges() { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(); var expression = new SqlSubStatementExpression(sqlStatement); _stageMock .Expect(mock => mock.ResolveSqlStatement(sqlStatement, _mappingResolutionContext)) .Return(sqlStatement); _groupAggregateSimplifierMock .Expect(mock => mock.SimplifyIfPossible(expression, expression.SqlStatement.SelectProjection)) .Return(expression); var result = _visitor.Visit(expression); _stageMock.VerifyAllExpectations(); _groupAggregateSimplifierMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(expression)); }
public void ResolveSubStatementReferenceExpression_CreatesNewExpressionWithReferences_ForNewExpressions_WithoutMembers() { var newExpression = Expression.New( TypeForNewExpression.GetConstructor(typeof(int)), new[] { new NamedExpression("const", Expression.Constant(0)) }); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(newExpression); var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement); var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression(newExpression, tableInfo, sqlTable, _context); var expectedResult = Expression.New( TypeForNewExpression.GetConstructor(typeof(int)), new Expression[] { new NamedExpression("m0", new SqlColumnDefinitionExpression(typeof(int), "q0", "const", false)) }); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result); }
public void VisitSubqueryExpressionTest_WithSqlTables() { var mainFromClause = ExpressionHelper.CreateMainFromClause <Cook>(); var querModel = ExpressionHelper.CreateQueryModel(mainFromClause); var expression = new SubQueryExpression(querModel); var fakeSqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement()); fakeSqlStatementBuilder.SqlTables.Add(_sqlTable); 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)); }
public void SetUp() { _dataInfo = new StreamedScalarValueInfo(typeof(int)); _resolvedElementExpressionReference = new SqlColumnDefinitionExpression(typeof(string), "q0", "element", false); _resolvedSelectProjection = new NamedExpression( null, new AggregationExpression(typeof(int), _resolvedElementExpressionReference, AggregationModifier.Min)); _associatedGroupingSelectExpression = new SqlGroupingSelectExpression( new NamedExpression("key", Expression.Constant("k")), new NamedExpression("element", Expression.Constant("e"))); _resolvedJoinedGroupingSubStatement = SqlStatementModelObjectMother.CreateSqlStatement(_associatedGroupingSelectExpression); _resolvedJoinedGroupingTable = new SqlTable( new ResolvedJoinedGroupingTableInfo( "q1", _resolvedJoinedGroupingSubStatement, _associatedGroupingSelectExpression, "q0"), JoinSemantics.Inner); _simplifiableResolvedSqlStatement = new SqlStatement( _dataInfo, _resolvedSelectProjection, new[] { _resolvedJoinedGroupingTable }, null, null, new Ordering[0], null, false, Expression.Constant(0), Expression.Constant(0)); _simplifiableUnresolvedProjection = new AggregationExpression( typeof(int), new SqlTableReferenceExpression(_resolvedJoinedGroupingTable), AggregationModifier.Count); _stageMock = MockRepository.GenerateStrictMock <IMappingResolutionStage> (); _context = new MappingResolutionContext(); _groupAggregateSimplifier = new GroupAggregateSimplifier(_stageMock, _context); }
public void VisitSqlSubStatementExpression_LeavesSqlSubStatementExpression_ForStreamedSequenceInfo() { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(Expression.Constant(new Cook())); var expression = new SqlSubStatementExpression(sqlStatement); _stageMock .Expect(mock => mock.ResolveSqlStatement(sqlStatement, _mappingResolutionContext)) .Return(sqlStatement); _groupAggregateSimplifier .Expect(mock => mock.SimplifyIfPossible(expression, sqlStatement.SelectProjection)) .Return(expression); var visitor = CreateVisitor(new SqlStatementBuilder(sqlStatement)); var result = visitor.VisitExpression(expression); _stageMock.VerifyAllExpectations(); _groupAggregateSimplifier.VerifyAllExpectations(); Assert.That(result, Is.TypeOf(typeof(SqlSubStatementExpression))); Assert.That(((SqlSubStatementExpression)result).SqlStatement, Is.SameAs(sqlStatement)); }
public void ResolveSqlStatement() { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable_WithUnresolvedTableInfo(typeof(Cook)); var tableReferenceExpression = new SqlTableReferenceExpression(new SqlTable(_fakeResolvedSimpleTableInfo, JoinSemantics.Inner)); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(tableReferenceExpression, new[] { sqlTable }); var fakeEntityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)); _resolverMock .Expect(mock => mock.ResolveTableInfo((UnresolvedTableInfo)((SqlTable)sqlStatement.SqlTables[0]).TableInfo, _uniqueIdentifierGenerator)) .Return(_fakeResolvedSimpleTableInfo); _resolverMock .Expect(mock => mock.ResolveSimpleTableInfo(tableReferenceExpression.SqlTable.GetResolvedTableInfo(), _uniqueIdentifierGenerator)) .Return(fakeEntityExpression); _resolverMock.Replay(); var newSqlStatment = _stage.ResolveSqlStatement(sqlStatement, _mappingResolutionContext); _resolverMock.VerifyAllExpectations(); Assert.That(((SqlTable)newSqlStatment.SqlTables[0]).TableInfo, Is.SameAs(_fakeResolvedSimpleTableInfo)); Assert.That(newSqlStatment.SelectProjection, Is.SameAs(fakeEntityExpression)); }
public void GenerateTextForOuterSqlStatement() { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement( _entityExpression, new[] { new SqlTable(new ResolvedSimpleTableInfo(typeof(int), "Table", "t"), JoinSemantics.Inner) }); var stage = new DefaultSqlGenerationStage(); stage.GenerateTextForOuterSqlStatement(_commandBuilder, sqlStatement); Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("SELECT [t].[ID],[t].[Name],[t].[City] FROM [Table] AS [t]")); var inMemoryProjection = _commandBuilder.GetInMemoryProjectionBody(); Assert.That(inMemoryProjection, Is.AssignableTo(typeof(MethodCallExpression))); var methodCallExpression = (MethodCallExpression)inMemoryProjection; Assert.That(methodCallExpression.Method, Is.EqualTo((typeof(IDatabaseResultRow).GetMethod("GetEntity").MakeGenericMethod(sqlStatement.SelectProjection.Type)))); Assert.That(methodCallExpression.Arguments.Count, Is.EqualTo(1)); Assert.That(((ColumnID[])((ConstantExpression)methodCallExpression.Arguments[0]).Value)[0].ColumnName, Is.EqualTo("ID")); Assert.That(((ColumnID[])((ConstantExpression)methodCallExpression.Arguments[0]).Value)[1].ColumnName, Is.EqualTo("Name")); Assert.That(((ColumnID[])((ConstantExpression)methodCallExpression.Arguments[0]).Value)[2].ColumnName, Is.EqualTo("City")); }
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 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(); 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"); var fakeSqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(); Assert.That(fakeSqlStatement, Is.Not.EqualTo(setOperationCombinedStatement.SqlStatement), "This is important for the test below."); _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(sqlStatement.SqlTables[0].TableInfo, _mappingResolutionContext)) .Return(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c")); _stageMock .Expect(mock => mock.ResolveSqlStatement(setOperationCombinedStatement.SqlStatement, _mappingResolutionContext)) .Return(fakeSqlStatement); _stageMock.Replay(); var resolvedSqlStatement = _visitor.ResolveSqlStatement(sqlStatement); _stageMock.VerifyAllExpectations(); Assert.That(resolvedSqlStatement.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo))); Assert.That(((StreamedSequenceInfo)resolvedSqlStatement.DataInfo).DataType, Is.EqualTo(typeof(IQueryable <>).MakeGenericType(typeof(Cook)))); Assert.That(resolvedSqlStatement.SelectProjection, Is.SameAs(fakeExpression)); Assert.That(resolvedSqlStatement.WhereCondition, Is.SameAs(fakeWhereCondition)); Assert.That(resolvedSqlStatement.TopExpression, Is.SameAs(fakeTopExpression)); Assert.That(resolvedSqlStatement.GroupByExpression, Is.SameAs(fakeGroupExpression)); Assert.That(resolvedSqlStatement.Orderings[0].Expression, Is.SameAs(fakeOrderExpression)); Assert.That(sqlStatement.Orderings[0].Expression, Is.SameAs(ordering.Expression)); Assert.That(resolvedSqlStatement.SetOperationCombinedStatements.Single().SqlStatement, Is.SameAs(fakeSqlStatement)); }
private static UnionResultOperator CreateValidResultOperator() { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(Expression.Constant(0)); return(new UnionResultOperator("x", typeof(int), new SqlSubStatementExpression(sqlStatement))); }