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); }
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 AddPreparedFromExpression(FromExpressionInfo fromExpressionInfo) { ArgumentUtility.CheckNotNull("fromExpressionInfo", fromExpressionInfo); if (fromExpressionInfo.WhereCondition != null) { SqlStatementBuilder.AddWhereCondition(fromExpressionInfo.WhereCondition); } foreach (var ordering in fromExpressionInfo.ExtractedOrderings) { SqlStatementBuilder.Orderings.Add(ordering); } SqlStatementBuilder.SqlTables.Add(fromExpressionInfo.SqlTable); }
protected override Expression VisitQuerySourceReference(QuerySourceReferenceExpression expression) { var groupJoinClause = expression.ReferencedQuerySource as GroupJoinClause; if (groupJoinClause != null) { var fromExpressionInfo = AnalyzeFromExpression( groupJoinClause.JoinClause.InnerSequence, Stage, _generator, MethodCallTransformerProvider, Context, _tableGenerator, _orderingExtractionPolicy); Context.AddExpressionMapping(new QuerySourceReferenceExpression(groupJoinClause.JoinClause), fromExpressionInfo.ItemSelector); var whereCondition = Stage.PrepareWhereExpression( Expression.Equal(groupJoinClause.JoinClause.OuterKeySelector, groupJoinClause.JoinClause.InnerKeySelector), Context); if (fromExpressionInfo.WhereCondition != null) { whereCondition = Expression.AndAlso(fromExpressionInfo.WhereCondition, whereCondition); } FromExpressionInfo = new FromExpressionInfo( fromExpressionInfo.SqlTable, fromExpressionInfo.ExtractedOrderings.ToArray(), fromExpressionInfo.ItemSelector, whereCondition); return(new SqlTableReferenceExpression(fromExpressionInfo.SqlTable)); } return(base.VisitQuerySourceReference(expression)); }
public void AddPreparedFromExpression_NoOrderings () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (); var preparedFromExpressionInfo = new FromExpressionInfo ( sqlTable, new Ordering[0], new SqlTableReferenceExpression (sqlTable), null); _visitor.SqlStatementBuilder.Orderings.Clear (); _visitor.AddPreparedFromExpression (preparedFromExpressionInfo); Assert.That (_visitor.SqlStatementBuilder.Orderings.Count, Is.EqualTo (0)); }
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 void AddPreparedFromExpression (FromExpressionInfo fromExpressionInfo) { ArgumentUtility.CheckNotNull ("fromExpressionInfo", fromExpressionInfo); if (fromExpressionInfo.WhereCondition != null) SqlStatementBuilder.AddWhereCondition (fromExpressionInfo.WhereCondition); foreach (var ordering in fromExpressionInfo.ExtractedOrderings) SqlStatementBuilder.Orderings.Add (ordering); SqlStatementBuilder.SqlTables.Add (fromExpressionInfo.SqlTable); }
protected override Expression VisitQuerySourceReferenceExpression (QuerySourceReferenceExpression expression) { var groupJoinClause = expression.ReferencedQuerySource as GroupJoinClause; if (groupJoinClause != null) { var fromExpressionInfo = AnalyzeFromExpression ( groupJoinClause.JoinClause.InnerSequence, Stage, _generator, MethodCallTransformerProvider, Context, _tableGenerator); Context.AddExpressionMapping (new QuerySourceReferenceExpression (groupJoinClause.JoinClause), fromExpressionInfo.ItemSelector); var whereCondition = Stage.PrepareWhereExpression ( Expression.Equal (groupJoinClause.JoinClause.OuterKeySelector, groupJoinClause.JoinClause.InnerKeySelector), Context); if (fromExpressionInfo.WhereCondition != null) whereCondition = Expression.AndAlso (fromExpressionInfo.WhereCondition, whereCondition); FromExpressionInfo = new FromExpressionInfo ( fromExpressionInfo.SqlTable, fromExpressionInfo.ExtractedOrderings.ToArray(), fromExpressionInfo.ItemSelector, whereCondition); return new SqlTableReferenceExpression (fromExpressionInfo.SqlTable); } return base.VisitQuerySourceReferenceExpression (expression); }
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 VisitMainFromClause_CreatesFromExpression () { var preparedSqlTable = SqlStatementModelObjectMother.CreateSqlTable(); var preparedFromExpressionInfo = new FromExpressionInfo ( preparedSqlTable, new Ordering[] { }, new SqlTableReferenceExpression (preparedSqlTable), null); _stageMock .Expect ( mock => mock.PrepareFromExpression ( Arg<Expression>.Matches (e => e == _mainFromClause.FromExpression), Arg<ISqlPreparationContext>.Matches (c => c != _context), Arg<Func<ITableInfo, SqlTable>>.Is.Anything)) .Return (preparedFromExpressionInfo); _stageMock.Replay(); _visitor.VisitMainFromClause (_mainFromClause, _queryModel); _stageMock.VerifyAllExpectations(); Assert.That (_visitor.SqlStatementBuilder.SqlTables, Is.EqualTo (new[] { preparedSqlTable })); Assert.That ( ((SqlTableReferenceExpression) _visitor.Context.GetExpressionMapping (new QuerySourceReferenceExpression (_mainFromClause))).SqlTable, Is.SameAs (preparedSqlTable)); }
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 AddPreparedFromExpression_OrderingIsAdded () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (); var ordering = new Ordering(Expression.Constant("order"), OrderingDirection.Asc); var preparedFromExpressionInfo = new FromExpressionInfo ( sqlTable, new[] { ordering }, new SqlTableReferenceExpression (sqlTable), null); _visitor.SqlStatementBuilder.Orderings.Clear (); _visitor.AddPreparedFromExpression (preparedFromExpressionInfo); Assert.That (_visitor.SqlStatementBuilder.Orderings.Count, Is.EqualTo (1)); Assert.That (_visitor.SqlStatementBuilder.Orderings[0], Is.SameAs (ordering)); }
public void AddQuerySource () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(); var preparedFromExpressionInfo = new FromExpressionInfo ( sqlTable, new Ordering[] { }, new SqlTableReferenceExpression (sqlTable), null); _stageMock .Expect ( mock => mock.PrepareFromExpression ( Arg.Is (_mainFromClause.FromExpression), Arg<ISqlPreparationContext>.Matches (c => c != _context), Arg<Func<ITableInfo, SqlTable>>.Is.Anything)) .Return (preparedFromExpressionInfo) .WhenCalled (mi => { var tableCreator = (Func<ITableInfo, SqlTable>) mi.Arguments[2]; var sampleTableInfo = new UnresolvedTableInfo (typeof (Cook)); var table = tableCreator (sampleTableInfo); Assert.That (table, Is.TypeOf (typeof (SqlTable))); Assert.That (((SqlTable) table).TableInfo, Is.SameAs (sampleTableInfo)); Assert.That (table.JoinSemantics, Is.EqualTo (JoinSemantics.Inner)); }); _stageMock.Replay(); var result = _visitor.AddQuerySource (_mainFromClause, _mainFromClause.FromExpression); _stageMock.VerifyAllExpectations(); Assert.That (result, Is.SameAs (sqlTable)); Assert.That (_visitor.Context.GetExpressionMapping (new QuerySourceReferenceExpression (_mainFromClause)), Is.Not.Null); }
public void VisitJoinClause_CreatesWhereCondition () { var joinClause = ExpressionHelper.CreateJoinClause<Cook>(); var preparedSqlTable = SqlStatementModelObjectMother.CreateSqlTable(); var preparedFromExpressionInfo = new FromExpressionInfo ( preparedSqlTable, new Ordering[] { }, new SqlTableReferenceExpression (preparedSqlTable), null); var fakeWhereCondition = Expression.Constant (1); _stageMock .Expect ( mock => mock.PrepareFromExpression ( Arg<Expression>.Matches (e => e == joinClause.InnerSequence), Arg<ISqlPreparationContext>.Is.Anything, Arg<Func<ITableInfo, SqlTable>>.Is.Anything)) .Return (preparedFromExpressionInfo); _stageMock .Expect ( mock => mock.PrepareWhereExpression ( Arg<Expression>.Is.Anything, Arg<ISqlPreparationContext>.Matches (c => c != _context))) .Return (fakeWhereCondition); _stageMock.Replay(); _visitor.VisitJoinClause (joinClause, _queryModel, 5); _stageMock.VerifyAllExpectations(); Assert.That (_visitor.SqlStatementBuilder.WhereCondition, Is.SameAs (fakeWhereCondition)); }
public void VisitAdditionalFromClause_WithWhereCondition_AddsWhereCondition () { var fromClause = ExpressionHelper.CreateAdditionalFromClause(); var preparedTable = new SqlTable (SqlStatementModelObjectMother.CreateResolvedTableInfo(), JoinSemantics.Inner); // TODO RMLNQSQL-2: Add existing where condition and assert that the new where condition is added, does not replace the original one. var whereCondition = ExpressionHelper.CreateExpression(typeof(bool)); var preparedFromExpressionInfo = new FromExpressionInfo ( preparedTable, new Ordering[] { }, new SqlTableReferenceExpression (preparedTable), whereCondition); _stageMock .Expect ( mock => mock.PrepareFromExpression ( Arg<Expression>.Matches (e => e == fromClause.FromExpression), Arg<ISqlPreparationContext>.Matches (c => c != _context), Arg < Func<ITableInfo, SqlTable>>.Is.Anything)) .Return (preparedFromExpressionInfo); _stageMock.Replay(); _visitor.VisitAdditionalFromClause (fromClause, _queryModel, 0); _stageMock.VerifyAllExpectations(); Assert.That (_visitor.SqlStatementBuilder.WhereCondition, Is.SameAs(whereCondition)); }
public void VisitAdditionalFromClause_AddsSqlTable_AndContextMapping () { var fakeSqlTableForMainFromClause = SqlStatementModelObjectMother.CreateSqlTable(); _visitor.SqlStatementBuilder.SqlTables.Add (fakeSqlTableForMainFromClause); var constantExpression = Expression.Constant (0); var additionalFromClause = new AdditionalFromClause ("additional", typeof (int), constantExpression); _queryModel.BodyClauses.Add (additionalFromClause); var preparedSqlTable = SqlStatementModelObjectMother.CreateSqlTable(); var preparedFromExpressionInfo = new FromExpressionInfo ( preparedSqlTable, new Ordering[] { }, new SqlTableReferenceExpression (preparedSqlTable), null); _stageMock .Expect ( mock => mock.PrepareFromExpression ( Arg<Expression>.Matches (e => e == constantExpression), Arg<ISqlPreparationContext>.Matches (c => c != _context), Arg<Func<ITableInfo, SqlTable>>.Is.Anything)) .Return (preparedFromExpressionInfo); _stageMock.Replay(); _visitor.VisitAdditionalFromClause (additionalFromClause, _queryModel, 0); _stageMock.VerifyAllExpectations(); Assert.That (_visitor.SqlStatementBuilder.SqlTables, Is.EqualTo (new[] { fakeSqlTableForMainFromClause, preparedSqlTable })); var contextMapping = _visitor.Context.GetExpressionMapping (new QuerySourceReferenceExpression (additionalFromClause)); Assert.That (contextMapping, Is.Not.Null); Assert.That (((SqlTableReferenceExpression) contextMapping).SqlTable, Is.SameAs (preparedSqlTable)); }
public void AddPreparedFromExpression_WhereConditionIsSet () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (); var whereCondition = Expression.Constant (true); var preparedFromExpressionInfo = new FromExpressionInfo ( sqlTable, new Ordering[0], new SqlTableReferenceExpression (sqlTable), whereCondition); _visitor.SqlStatementBuilder.WhereCondition = null; _visitor.AddPreparedFromExpression (preparedFromExpressionInfo); Assert.That (_visitor.SqlStatementBuilder.WhereCondition, Is.SameAs (whereCondition)); }
public void AddPreparedFromExpression_WhereConditionIsAdded () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (); var whereCondition = Expression.Constant(true); var preparedFromExpressionInfo = new FromExpressionInfo ( sqlTable, new Ordering[0] , new SqlTableReferenceExpression (sqlTable), whereCondition); var originalWhereCondition = Expression.Constant (false); _visitor.SqlStatementBuilder.WhereCondition = originalWhereCondition; _visitor.AddPreparedFromExpression (preparedFromExpressionInfo); var expectedCombinedWhereCondition = Expression.AndAlso (originalWhereCondition, whereCondition); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedCombinedWhereCondition, _visitor.SqlStatementBuilder.WhereCondition); }
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; }
public void AddPreparedFromExpression_NoWhereCondition () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (); var preparedFromExpressionInfo = new FromExpressionInfo ( sqlTable, new Ordering[0], new SqlTableReferenceExpression (sqlTable), null); var originalWhereCondition = Expression.Constant (false); _visitor.SqlStatementBuilder.WhereCondition = originalWhereCondition; _visitor.AddPreparedFromExpression (preparedFromExpressionInfo); Assert.That (_visitor.SqlStatementBuilder.WhereCondition, Is.SameAs (originalWhereCondition)); }
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 HandleResultOperator_AllAfterGroupExpression () { _sqlStatementBuilder.GroupByExpression = Expression.Constant ("group"); var predicate = Expression.Constant (true); var preparedPredicate = Expression.Constant (false); var resultOperator = new AllResultOperator (predicate); var sqlStatement = _sqlStatementBuilder.GetSqlStatement (); var fakePreparedSelectProjection = Expression.Constant (false); var sqlTable = _sqlStatementBuilder.SqlTables[0]; var fakeFromExpressionInfo = new FromExpressionInfo (sqlTable, new Ordering[0], new SqlTableReferenceExpression (sqlTable), null); _stageMock .Expect ( mock => mock.PrepareFromExpression (Arg<Expression>.Is.Anything, Arg.Is (_context), Arg<Func<ITableInfo, SqlTable>>.Is.Anything)) .Return (fakeFromExpressionInfo); _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]; Assert.That (selectProjection, Is.TypeOf (typeof (UnaryExpression))); Assert.That (selectProjection.NodeType, Is.EqualTo(ExpressionType.Not)); Assert.That (((UnaryExpression) selectProjection).Operand, Is.TypeOf (typeof (SqlExistsExpression))); Assert.That (((SqlExistsExpression) ((UnaryExpression) selectProjection).Operand).Expression, Is.TypeOf (typeof (SqlSubStatementExpression))); }) .Return (fakePreparedSelectProjection); _stageMock.Replay (); _handler.HandleResultOperator (resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context); }