public void PrepareTopExpression () { var result = _stage.PrepareTopExpression (_querySourceReferenceExpression, _context); var expectedExpression = new SqlTableReferenceExpression (_sqlTable); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, result); }
public void ToString_SqlTableWithUnresolvedTableInfo () { var sqlTable = new SqlTable (new UnresolvedTableInfo (typeof (Cook)), JoinSemantics.Left); var expression = new SqlTableReferenceExpression (sqlTable); var result = expression.ToString(); Assert.That (result, Is.EqualTo ("TABLE-REF(UnresolvedTableInfo(Cook))")); }
public void TryGetExpressiontMappingFromHierarchy () { var querySourceReferenceExpression = new QuerySourceReferenceExpression (_source); var sqlTableReferenceExpression = new SqlTableReferenceExpression (_sqlTable); _context.AddExpressionMapping (querySourceReferenceExpression, sqlTableReferenceExpression); Expression result = _context.GetExpressionMapping (querySourceReferenceExpression); Assert.That (result, Is.SameAs (sqlTableReferenceExpression)); }
public void CreateSqlTableForSubStatement_WithoutOrderings () { var statementWithoutOrderings = SqlStatementModelObjectMother.CreateSqlStatementWithCook(); var result = _factory.CreateSqlTableForStatement (statementWithoutOrderings, 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, Is.SameAs (statementWithoutOrderings)); Assert.That (result.WhereCondition, Is.Null); Assert.That (result.ExtractedOrderings, Is.Empty); var expectedItemSelector = new SqlTableReferenceExpression (result.SqlTable); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedItemSelector, result.ItemSelector); }
public void SetUp () { _stageMock = MockRepository.GenerateMock<ISqlPreparationStage> (); _generator = new UniqueIdentifierGenerator (); _context = SqlStatementModelObjectMother.CreateSqlPreparationContext (); _handler = new SkipResultOperatorHandler (); _sqlTable = new SqlTable (new UnresolvedTableInfo (typeof (Cook)), JoinSemantics.Inner); _selectProjection = new SqlTableReferenceExpression (_sqlTable); _ordering = new Ordering (Expression.Constant (7), OrderingDirection.Asc); _sqlStatementBuilder = new SqlStatementBuilder { SelectProjection = _selectProjection, DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook ())), SqlTables = { _sqlTable }, }; _tupleCtor = _tupleCtor = typeof (KeyValuePair<Cook, int>).GetConstructor (new[] { typeof (Cook), typeof (int) }); }
protected override Expression VisitMemberExpression (MemberExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var preparedMemberExpression = (MemberExpression) TranslateExpression (expression, Context, Stage, MethodCallTransformerProvider); var joinInfo = new UnresolvedCollectionJoinInfo (preparedMemberExpression.Expression, preparedMemberExpression.Member); var joinedTable = new SqlJoinedTable (joinInfo, JoinSemantics.Inner); var oldStyleJoinedTable = _tableGenerator (joinedTable); var sqlTableReferenceExpression = new SqlTableReferenceExpression (oldStyleJoinedTable); FromExpressionInfo = new FromExpressionInfo ( oldStyleJoinedTable, new Ordering[0], sqlTableReferenceExpression, new JoinConditionExpression (joinedTable)); return sqlTableReferenceExpression; }
public void GetExpressionMapping_GetFromParentContext () { var querySourceReferenceExpression = new QuerySourceReferenceExpression (_parentSource); var sqlTableReferenceExpression = new SqlTableReferenceExpression (_parentSqlTable); _parentContext.AddExpressionMapping (querySourceReferenceExpression, sqlTableReferenceExpression); Assert.That (_contextWithParent.GetExpressionMapping (querySourceReferenceExpression), Is.SameAs (sqlTableReferenceExpression)); }
public void AddJoinClause () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(); var preparedExpression = new SqlTableReferenceExpression (sqlTable); var joinClause = ExpressionHelper.CreateJoinClause<Cook>(); var preparedFromExpressionInfo = new FromExpressionInfo ( sqlTable, new Ordering[] { }, new SqlTableReferenceExpression (sqlTable), null); _stageMock .Expect ( mock => mock.PrepareFromExpression ( Arg<Expression>.Matches (e => e == joinClause.InnerSequence), Arg<ISqlPreparationContext>.Matches (c => c != _context), Arg < Func<ITableInfo, SqlTable>>.Is.Anything)) .Return (preparedFromExpressionInfo); _stageMock .Expect ( mock => mock.PrepareWhereExpression ( Arg<Expression>.Matches ( e => ((BinaryExpression) e).Left == joinClause.OuterKeySelector && ((BinaryExpression) e).Right == joinClause.InnerKeySelector), Arg<ISqlPreparationContext>.Matches (c => c != _context))) .Return (preparedExpression); _stageMock.Replay(); var result = _visitor.AddJoinClause (joinClause); _stageMock.VerifyAllExpectations(); Assert.That (result, Is.SameAs (sqlTable)); Assert.That (_visitor.SqlStatementBuilder.WhereCondition, Is.SameAs (preparedExpression)); }
public virtual SqlEntityExpression ResolveEntityRefMemberExpression (SqlEntityRefMemberExpression expression, IJoinInfo joinInfo, IMappingResolutionContext context) { ArgumentUtility.CheckNotNull ("expression", expression); ArgumentUtility.CheckNotNull ("joinInfo", joinInfo); ArgumentUtility.CheckNotNull ("context", context); var originatingSqlTable = context.GetSqlTableForEntityExpression (expression.OriginatingEntity); var join = originatingSqlTable.GetOrAddLeftJoin (joinInfo, expression.MemberInfo); join.JoinInfo = ResolveJoinInfo (join.JoinInfo, context); var sqlTableReferenceExpression = new SqlTableReferenceExpression (join); return (SqlEntityExpression) ResolveExpression (sqlTableReferenceExpression, context); }
public void SetUp () { _tableReferenceExpression = new SqlTableReferenceExpression (SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook))); }
public override Expression VisitSqlSubStatementExpression (SqlSubStatementExpression expression) { var newExpression = base.VisitSqlSubStatementExpression (expression); var newExpressionAsSqlSubStatementExpression = newExpression as SqlSubStatementExpression; // Substatements returning a single value need to be moved to the FROM part of the SQL statement because they might return more than one column. // Since a SqlSubStatementExpression must return a single row anyway, we can do this. // (However, errors that would have arisen because the statement does not return exactly one row will not be found.) if (newExpressionAsSqlSubStatementExpression != null && newExpressionAsSqlSubStatementExpression.SqlStatement.DataInfo is StreamedSingleValueInfo) { var sqlTable = newExpressionAsSqlSubStatementExpression.ConvertToSqlTable (Generator.GetUniqueIdentifier ("q")); var sqlTableReferenceExpression = new SqlTableReferenceExpression (sqlTable); Context.AddSqlTable (sqlTable, _sqlStatementBuilder); return VisitExpression (sqlTableReferenceExpression); } return newExpression; }
public Expression VisitSqlTableReferenceExpression (SqlTableReferenceExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var resolvedExpression = _stage.ResolveTableReferenceExpression (expression, _context); return VisitExpression (resolvedExpression); }
public void VisitSqlTableReferenceExpression_RevisitsResult () { var tableReferenceExpression = new SqlTableReferenceExpression (_sqlTable); var fakeResult = Expression.Constant (0); _stageMock .Expect (mock => mock.ResolveTableReferenceExpression (tableReferenceExpression, _mappingResolutionContext)) .Return (fakeResult); _stageMock.Replay(); _resolverMock .Expect (mock => mock.ResolveConstantExpression (fakeResult)) .Return (fakeResult); _resolverMock.Replay(); var result = _visitor.VisitExpression (tableReferenceExpression); _stageMock.VerifyAllExpectations(); _resolverMock.VerifyAllExpectations(); Assert.That (result, Is.SameAs (fakeResult)); }
public void VisitExpression_ReferenceToOtherTable () { var visitor = new GroupAggregateSimplifier.SimplifyingVisitor (_resolvedJoinedGroupingTable, _associatedGroupingSelectExpression.ElementExpression); var input = new SqlTableReferenceExpression (SqlStatementModelObjectMother.CreateSqlTable()); visitor.VisitExpression (input); Assert.That (visitor.CanBeTransferredToGroupingSource, Is.False); }
public void VisitExpression_ReferenceToRightTable () { var visitor = new GroupAggregateSimplifier.SimplifyingVisitor (_resolvedJoinedGroupingTable, _associatedGroupingSelectExpression.ElementExpression); var input = new SqlTableReferenceExpression (_resolvedJoinedGroupingTable); var result = visitor.VisitExpression (input); Assert.That (visitor.CanBeTransferredToGroupingSource, Is.True); Assert.That (result, Is.SameAs (_associatedGroupingSelectExpression.ElementExpression)); }
public void SimplifyIfPossible_WithUnresolvedProjection_NotMatchingResolvedOned_NoAggregation () { var expression = new SqlSubStatementExpression (_simplifiableResolvedSqlStatement); var nonSimplifiableProjection = new SqlTableReferenceExpression (SqlStatementModelObjectMother.CreateSqlTable ()); _groupAggregateSimplifier.SimplifyIfPossible (expression, nonSimplifiableProjection); }
public void ResolveTableReferenceExpression () { var expression = new SqlTableReferenceExpression (SqlStatementModelObjectMother.CreateSqlTable_WithResolvedTableInfo (typeof (Cook))); var fakeResult = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook)); _resolverMock .Expect (mock => mock.ResolveSimpleTableInfo (expression.SqlTable.GetResolvedTableInfo(), _uniqueIdentifierGenerator)) .Return (fakeResult); var result = _stage.ResolveTableReferenceExpression (expression, _mappingResolutionContext); Assert.That (result, Is.SameAs (fakeResult)); }
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 Expression ResolveTableReferenceExpression (SqlTableReferenceExpression expression, IMappingResolutionContext context) { ArgumentUtility.CheckNotNull ("expression", expression); ArgumentUtility.CheckNotNull ("context", context); return expression.SqlTable.GetResolvedTableInfo ().ResolveReference (expression.SqlTable, _resolver, context, _uniqueIdentifierGenerator); }
public Expression VisitSqlTableReferenceExpression (SqlTableReferenceExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var tableInfo = new UnresolvedGroupReferenceTableInfo (expression.SqlTable); var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner); FromExpressionInfo = new FromExpressionInfo (sqlTable, new Ordering[0], new SqlTableReferenceExpression (sqlTable), null); return expression; }
protected override Expression VisitConstantExpression (ConstantExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var itemType = ReflectionUtility.GetItemTypeOfClosedGenericIEnumerable (expression.Type, "from expression"); var sqlTable = _tableGenerator (new UnresolvedTableInfo (itemType)); var sqlTableReferenceExpression = new SqlTableReferenceExpression (sqlTable); FromExpressionInfo = new FromExpressionInfo (sqlTable, new Ordering[0], sqlTableReferenceExpression, null); return sqlTableReferenceExpression; }
public void VisitSqlTableReferenceExpression_Grouping () { var sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (IGrouping<string, int>), "test", "t0"), JoinSemantics.Inner); var expression = new SqlTableReferenceExpression (sqlTable); var result = SqlPreparationFromExpressionVisitor.AnalyzeFromExpression ( expression, _stageMock, _generator, _methodCallTransformerProvider, _context, null); Assert.That (result.SqlTable, Is.Not.SameAs (sqlTable)); Assert.That (result.WhereCondition, Is.Null); Assert.That (result.ExtractedOrderings, Is.Empty); var expectedItemSelector = new SqlTableReferenceExpression (result.SqlTable); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedItemSelector, result.ItemSelector); var tableInfo = ((SqlTable) result.SqlTable).TableInfo; Assert.That (tableInfo, Is.TypeOf (typeof (UnresolvedGroupReferenceTableInfo))); var castTableInfo = (UnresolvedGroupReferenceTableInfo) tableInfo; Assert.That (castTableInfo.ItemType, Is.SameAs (typeof (int))); Assert.That (castTableInfo.ReferencedGroupSource, Is.SameAs (sqlTable)); Assert.That (result.SqlTable.JoinSemantics, Is.EqualTo (JoinSemantics.Inner)); }
public void VisitSelectClause_CreatesSelectProjection () { var preparedExpression = new SqlTableReferenceExpression (SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook))); _stageMock .Expect ( mock => mock.PrepareSelectExpression ( Arg<Expression>.Matches (e => e == _selectClause.Selector), Arg<ISqlPreparationContext>.Matches (c => c != _context))) .Return (preparedExpression); _stageMock.Replay(); _visitor.VisitSelectClause (_selectClause, _queryModel); _stageMock.VerifyAllExpectations(); Assert.That (_visitor.SqlStatementBuilder.SelectProjection, Is.SameAs (preparedExpression)); Assert.That (_visitor.SqlStatementBuilder.DataInfo, Is.TypeOf (typeof (StreamedSequenceInfo))); Assert.That (((StreamedSequenceInfo) _visitor.SqlStatementBuilder.DataInfo).DataType, Is.EqualTo (_selectClause.GetOutputDataInfo().DataType)); }
public void ToString_SqlJoinedTableWithResolvedJoinInfo () { var sqlTable = new SqlJoinedTable ( new ResolvedJoinInfo ( new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), Expression.Constant (true)), JoinSemantics.Left); var expression = new SqlTableReferenceExpression (sqlTable); var result = expression.ToString(); Assert.That (result, Is.EqualTo ("TABLE-REF(c)")); }
public void ToString_OtherSqlTable () { var sqlTable = new OtherSqlTable (typeof (Cook), JoinSemantics.Left); var expression = new SqlTableReferenceExpression (sqlTable); var result = expression.ToString(); Assert.That (result, Is.EqualTo ("TABLE-REF (OtherSqlTable (Cook))")); }
public void HandleResultOperator_DetectConstantKeysAndReplaceWithSubStatement () { var keySelector = Expression.Constant ("keySelector"); var elementSelector = Expression.Constant ("elementSelector"); var resultOperator = new GroupResultOperator ("itemName", keySelector, elementSelector); var preparedConstantKeySelector = Expression.Constant ("test"); _stageMock .Expect (mock => mock.PrepareResultOperatorItemExpression (keySelector, _context)) .Return (preparedConstantKeySelector); _stageMock .Expect (mock => mock.PrepareResultOperatorItemExpression (elementSelector, _context)) .Return (elementSelector); _stageMock.Replay (); _handler.HandleResultOperator (resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context); _stageMock.VerifyAllExpectations (); Assert.That (_sqlStatementBuilder.SqlTables.Count, Is.EqualTo (2)); Assert.That (_sqlStatementBuilder.SqlTables[1], Is.TypeOf (typeof (SqlTable))); Assert.That (((SqlTable) _sqlStatementBuilder.SqlTables[1]).TableInfo, Is.TypeOf (typeof (ResolvedSubStatementTableInfo))); var groupKeyTableTableInfo = (ResolvedSubStatementTableInfo) ((SqlTable) _sqlStatementBuilder.SqlTables[1]).TableInfo; var expectedSelectExpression = new NamedExpression (null, preparedConstantKeySelector); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedSelectExpression, groupKeyTableTableInfo.SqlStatement.SelectProjection); var expectedStatement = new SqlStatementBuilder { DataInfo = new StreamedSequenceInfo (typeof (IEnumerable<string>), groupKeyTableTableInfo.SqlStatement.SelectProjection), SelectProjection = groupKeyTableTableInfo.SqlStatement.SelectProjection } .GetSqlStatement (); Assert.That (groupKeyTableTableInfo.SqlStatement, Is.EqualTo (expectedStatement)); var expectedGroupGyExpression = new SqlTableReferenceExpression (_sqlStatementBuilder.SqlTables[1]); SqlExpressionTreeComparer.CheckAreEqualTrees (_sqlStatementBuilder.GroupByExpression, expectedGroupGyExpression); SqlExpressionTreeComparer.CheckAreEqualTrees ( _sqlStatementBuilder.SelectProjection, SqlGroupingSelectExpression.CreateWithNames (expectedGroupGyExpression, elementSelector)); }
public void VisitQuerySourceReferenceExpression_WithNonNullWhereCondition () { var memberInfo = typeof (Cook).GetProperty ("Assistants"); var sqlTableReferenceExpression = new SqlTableReferenceExpression (SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook))); var innerSequenceExpression = Expression.MakeMemberAccess ( sqlTableReferenceExpression, memberInfo); var joinClause = new JoinClause ( "x", typeof (Cook[]), innerSequenceExpression, Expression.Constant (new Cook()), Expression.Constant (new Cook())); var groupJoinClause = new GroupJoinClause ("g", typeof (Cook[]), joinClause); var querySourceReferenceExpression = new QuerySourceReferenceExpression (groupJoinClause); var fakeWhereExpression = Expression.Constant (true); _stageMock .Expect (mock => mock.PrepareWhereExpression (Arg<Expression>.Matches (e => e is BinaryExpression), Arg.Is (_context))) .WhenCalled ( mi => SqlExpressionTreeComparer.CheckAreEqualTrees ( Expression.Equal (groupJoinClause.JoinClause.OuterKeySelector, groupJoinClause.JoinClause.InnerKeySelector), (Expression) mi.Arguments[0])) .Return (fakeWhereExpression); _stageMock.Replay(); _visitor.VisitQuerySourceReferenceExpression (querySourceReferenceExpression); _stageMock.VerifyAllExpectations(); Assert.That (_visitor.FromExpressionInfo != null); // inline condition because of ReSharper var fromExpressionInfo = (FromExpressionInfo) _visitor.FromExpressionInfo; Assert.That (fromExpressionInfo.WhereCondition, Is.AssignableTo (typeof (BinaryExpression))); Assert.That (fromExpressionInfo.WhereCondition.NodeType, Is.EqualTo(ExpressionType.AndAlso)); Assert.That (((BinaryExpression) fromExpressionInfo.WhereCondition).Left, Is.TypeOf(typeof(JoinConditionExpression))); Assert.That (((JoinConditionExpression) ((BinaryExpression) fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinInfo, Is.TypeOf (typeof (UnresolvedCollectionJoinInfo))); Assert.That ( ((UnresolvedCollectionJoinInfo) ((JoinConditionExpression) ((BinaryExpression) fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinInfo).SourceExpression, Is.SameAs(sqlTableReferenceExpression)); Assert.That ( ((UnresolvedCollectionJoinInfo) ((JoinConditionExpression) ((BinaryExpression) fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinInfo).MemberInfo, Is.SameAs (memberInfo)); Assert.That (((JoinConditionExpression) ((BinaryExpression) fromExpressionInfo.WhereCondition).Left).JoinedTable.JoinSemantics, Is.EqualTo(JoinSemantics.Inner)); Assert.That (((BinaryExpression) fromExpressionInfo.WhereCondition).Right, Is.SameAs (fakeWhereExpression)); }
public void ResolveGroupByExpression_ResolvesExpression () { var expression = new SqlTableReferenceExpression (_sqlTable); var fakeResult = Expression.Constant (0); _stageMock .Expect (mock => mock.ResolveGroupByExpression (expression, _mappingResolutionContext)) .Return (fakeResult); _stageMock.Replay (); var result = _visitor.ResolveGroupByExpression (expression); _stageMock.VerifyAllExpectations (); Assert.That (result, Is.SameAs (fakeResult)); }
public void ToString_SqlJoinedTableWithUnresolvedJoinInfo () { var sqlTable = new SqlJoinedTable (SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(), JoinSemantics.Left); var expression = new SqlTableReferenceExpression (sqlTable); var result = expression.ToString(); Assert.That (result, Is.EqualTo ("TABLE-REF(UnresolvedJoinInfo(Cook))")); }
public void VisitQuerySourceReferenceExpression_WithExtractedOrderings () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook)); var sqlTableReferenceExpression = new SqlTableReferenceExpression (sqlTable); var selectProjection = new NamedExpression("test", Expression.MakeMemberAccess (sqlTableReferenceExpression, typeof (Cook).GetProperty ("Name"))); var orderingExpression = Expression.MakeMemberAccess (sqlTableReferenceExpression, typeof (Cook).GetProperty ("ID")); var sqlStatement = new SqlStatementBuilder { DataInfo = new StreamedSequenceInfo(typeof (DateTime[]), Expression.Constant (new DateTime (2000, 1, 1))), SelectProjection = selectProjection, SqlTables = { sqlTable }, Orderings = { new Ordering (orderingExpression, OrderingDirection.Asc) } }.GetSqlStatement(); var fakeSelectExpression = Expression.Constant (new KeyValuePair<string, int>("test", 5)); var fakeWhereExpression = Expression.Constant (true); var innerSequenceExpression = new SqlSubStatementExpression (sqlStatement); var joinClause = new JoinClause ( "x", typeof (Cook[]), innerSequenceExpression, Expression.Constant (new Cook ()), Expression.Constant (new Cook ())); var groupJoinClause = new GroupJoinClause ("g", typeof (Cook[]), joinClause); var querySourceReferenceExpression = new QuerySourceReferenceExpression (groupJoinClause); _stageMock .Expect (mock => mock.PrepareSelectExpression(Arg<Expression>.Is.Anything, Arg<ISqlPreparationContext>.Is.Anything)) .Return (fakeSelectExpression); _stageMock .Expect (mock => mock.PrepareWhereExpression (Arg<Expression>.Matches (e => e is BinaryExpression), Arg.Is (_context))) .WhenCalled ( mi => SqlExpressionTreeComparer.CheckAreEqualTrees ( Expression.Equal (groupJoinClause.JoinClause.OuterKeySelector, groupJoinClause.JoinClause.InnerKeySelector), (Expression) mi.Arguments[0])) .Return (fakeWhereExpression); _stageMock.Replay (); _visitor.VisitQuerySourceReferenceExpression (querySourceReferenceExpression); _stageMock.VerifyAllExpectations (); Assert.That (_visitor.FromExpressionInfo != null); // inline condition because of ReSharper var fromExpressionInfo = (FromExpressionInfo) _visitor.FromExpressionInfo; Assert.That (fromExpressionInfo.ExtractedOrderings.Count, Is.EqualTo(1)); Assert.That (fromExpressionInfo.ExtractedOrderings[0].Expression, Is.AssignableTo(typeof(MemberExpression))); Assert.That (((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression, Is.TypeOf(typeof(SqlTableReferenceExpression))); Assert.That ( ((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable, Is.TypeOf (typeof (SqlTable))); Assert.That ( ((SqlTable) ((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable).TableInfo, Is.TypeOf (typeof (ResolvedSubStatementTableInfo))); var resolvedSubStatementtableInfo = (ResolvedSubStatementTableInfo) ((SqlTable) ((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable).TableInfo; Assert.That (resolvedSubStatementtableInfo.SqlStatement.SelectProjection, Is.SameAs(fakeSelectExpression)); Assert.That (resolvedSubStatementtableInfo.SqlStatement.Orderings.Count, Is.EqualTo (0)); Assert.That (((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Member, Is.EqualTo(typeof(KeyValuePair<,>).MakeGenericType(typeof(string), typeof(int)).GetProperty("Value"))); Assert.That (fromExpressionInfo.ItemSelector, Is.AssignableTo (typeof (MemberExpression))); Assert.That (((MemberExpression) fromExpressionInfo.ItemSelector).Expression, Is.TypeOf(typeof(SqlTableReferenceExpression))); Assert.That (((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ItemSelector).Expression).SqlTable, Is.TypeOf (typeof (SqlTable))); Assert.That ( ((SqlTable) ((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ItemSelector).Expression).SqlTable).TableInfo, Is.TypeOf (typeof (ResolvedSubStatementTableInfo))); Assert.That (((MemberExpression) fromExpressionInfo.ItemSelector).Member, Is.EqualTo (typeof (KeyValuePair<,>).MakeGenericType (typeof (string), typeof (int)).GetProperty ("Key"))); }