Exemple #1
0
    /// <summary>
    /// Clones this item.
    /// </summary>
    /// <param name="cloneContext">The clones of all query source clauses are registered with this <see cref="CloneContext"/>.</param>
    /// <returns>A clone of this item.</returns>
    virtual public Ordering Clone (CloneContext cloneContext)
    {
      ArgumentUtility.CheckNotNull ("cloneContext", cloneContext);

      var clone = new Ordering (Expression, OrderingDirection);
      return clone;
    }
 public SqlRowNumberExpression (Ordering[] orderings)
     : base (typeof (int))
 {
   ArgumentUtility.CheckNotNull ("orderings", orderings);
   ArgumentUtility.CheckNotEmpty ("orderings", orderings);
   
   _orderings = Array.AsReadOnly (orderings);
 }
Exemple #3
0
    public void InitializeWithExpressionAndOrderDirectionAsc()
    {
      var expression = ExpressionHelper.CreateExpression ();

      var ordering = new Ordering (expression, OrderingDirection.Asc);

      Assert.That (ordering.Expression, Is.SameAs (expression));
      Assert.That (ordering.OrderingDirection, Is.EqualTo (OrderingDirection.Asc));
    }
 public FromExpressionInfo (SqlTable sqlTable, Ordering[] extractedOrderings, Expression itemSelector, Expression whereCondition)
 {
   ArgumentUtility.CheckNotNull ("sqlTable", sqlTable);
   ArgumentUtility.CheckNotNull ("extractedOrderings", extractedOrderings);
   ArgumentUtility.CheckNotNull ("itemSelector", itemSelector);
   
   SqlTable = sqlTable;
   ExtractedOrderings = Array.AsReadOnly(extractedOrderings);
   ItemSelector = itemSelector;
   WhereCondition = whereCondition;
 }
    public void HandleResultOperator_WithOrderingsAndTopExpression ()
    {
      _sqlStatementBuilder.TopExpression = Expression.Constant ("top");
      var ordering = new Ordering (Expression.Constant ("order"), OrderingDirection.Asc);
      _sqlStatementBuilder.Orderings.Add (ordering);
      var averageResultOperator = new MaxResultOperator ();

      _handler.HandleResultOperator (averageResultOperator, _sqlStatementBuilder, _generator, _stage, _context);

      Assert.That (_sqlStatementBuilder.Orderings.Count, Is.EqualTo (0));
      Assert.That (
          ((ResolvedSubStatementTableInfo) ((SqlTable) _sqlStatementBuilder.SqlTables[0]).TableInfo).SqlStatement.Orderings.Count, Is.EqualTo (1));
      Assert.That (
          ((ResolvedSubStatementTableInfo) ((SqlTable) _sqlStatementBuilder.SqlTables[0]).TableInfo).SqlStatement.Orderings[0], Is.SameAs(ordering));
    }
    public void SetUp ()
    {
      _mockRepository = new MockRepository();
      _visitorMock = _mockRepository.StrictMock<TestQueryModelVisitor>();

      _bodyClauseMock1 = _mockRepository.StrictMock<IBodyClause>();
      _bodyClauseMock2 = _mockRepository.StrictMock<IBodyClause>();

      _ordering1 = new Ordering (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);
      _ordering2 = new Ordering (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);

      _resultOperator1 = new TestResultOperator();
      _resultOperator2 = new TestResultOperator();

      _queryModel = ExpressionHelper.CreateQueryModel<Cook>();
      _orderByClause = ExpressionHelper.CreateOrderByClause();
      _groupJoinClause = ExpressionHelper.CreateGroupJoinClause<Cook>();
    }
    public void SetUp ()
    {
      _mockRepository = new MockRepository();
      _visitorMock = _mockRepository.StrictMock<QueryModelVisitorBase>();
      _testVisitor = new TestQueryModelVisitor ();

      _bodyClauseMock1 = _mockRepository.StrictMock<WhereClause> (ExpressionHelper.CreateExpression());
      _bodyClauseMock2 = _mockRepository.StrictMock<WhereClause> (ExpressionHelper.CreateExpression());

      _orderingMock1 = _mockRepository.StrictMock<Ordering> (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);
      _orderingMock2 = _mockRepository.StrictMock<Ordering> (ExpressionHelper.CreateExpression(), OrderingDirection.Asc);

      _resultOperatorMock1 = _mockRepository.StrictMock<ResultOperatorBase> ();
      _resultOperatorMock2 = _mockRepository.StrictMock<ResultOperatorBase> ();

      _queryModel = ExpressionHelper.CreateQueryModel<Cook> ();
      _orderByClause = ExpressionHelper.CreateOrderByClause ();
      _groupJoinClause = ExpressionHelper.CreateGroupJoinClause<Cook> ();
    }
    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 VisitChildren(ExpressionVisitor visitor)
        {
            var newColumnExpression = visitor.Visit(ColumnExpression) as ColumnExpression;

            var newOrderings = new List<Ordering>();
            var recreate = false;
            foreach (var ordering in _orderings)
            {
                var newOrdering = new Ordering(visitor.Visit(ordering.Expression), ordering.OrderingDirection);
                newOrderings.Add(newOrdering);
                recreate |= newOrdering.Expression != ordering.Expression;
            }

            if (recreate ||
                (newColumnExpression != null && ColumnExpression != newColumnExpression))
            {
                return new RowNumberExpression(newColumnExpression, newOrderings);
            }

            return this;
        }
    public void Equals_EqualStatementsWithAllMembers ()
    {
      var dataInfo = new TestStreamedValueInfo (typeof (int));
      var isDistinctQuery = BooleanObjectMother.GetRandomBoolean();
      var selectProjection = Expression.Constant (1);
      var sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner);
      var ordering = new Ordering (Expression.Constant ("ordering"), OrderingDirection.Asc);
      var whereCondition = Expression.Constant (true);
      var topExpression = Expression.Constant ("top");
      var rowNumberSelector = Expression.Constant ("selector");
      var currentRowNumberOffset = Expression.Constant (1);
      var groupByExpression = Expression.Constant ("group");

      var sqlStatement1 = new SqlStatement (
          dataInfo,
          selectProjection,
          new[] { sqlTable },
          whereCondition,
          groupByExpression,
          new[] { ordering },
          topExpression,
          isDistinctQuery,
          rowNumberSelector,
          currentRowNumberOffset);

      var sqlStatement2 = new SqlStatement (
          dataInfo,
          selectProjection,
          new[] { sqlTable },
          whereCondition,
          groupByExpression,
          new[] { ordering },
          topExpression,
          isDistinctQuery,
          rowNumberSelector,
          currentRowNumberOffset);

      Assert.That (sqlStatement1.Equals (sqlStatement2), Is.True);
    }
        public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
        {
            if (_query.OrderByPredicate == null)
            {
                _query.OrderByPredicate = ODataQueryPart.OrderBy();
            }

            if (ordering.Expression.NodeType == ExpressionType.MemberAccess)
            {
                var memberExpression = (MemberExpression)ordering.Expression;

                var direction = (ordering.OrderingDirection == OrderingDirection.Asc)
                    ? ODataOrderingDirection.Asc
                    : ODataOrderingDirection.Desc;

                var o = ODataQueryPart.Ordering(memberExpression.Member.Name, direction);

                _query.OrderByPredicate.AddOrdering(o);
            }

            base.VisitOrdering(ordering, queryModel, orderByClause, index);
        }
    public void Initialization_WithExistingSqlStatement ()
    {
      var isDistinctQuery = BooleanObjectMother.GetRandomBoolean();
      var selectProjection = Expression.Constant ("select");
      var whereCondition = Expression.Constant (true);
      var topExpression = Expression.Constant ("top");
      var sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner);
      var ordering = new Ordering (Expression.Constant ("order"), OrderingDirection.Desc);
      var rowNumberSelector = Expression.Constant("selector");
      var currentRowNumberOffset = Expression.Constant(1);
      var groupExpression = Expression.Constant ("group");

      var sqlStatement = new SqlStatement (
          new TestStreamedValueInfo (typeof (int)),
          selectProjection,
          new[] { sqlTable },
          whereCondition,
          groupExpression,
          new[] { ordering },
          topExpression,
          isDistinctQuery,
          rowNumberSelector,
          currentRowNumberOffset);

      var testedBuilder = new SqlStatementBuilder (sqlStatement);

      Assert.That (testedBuilder.SelectProjection, Is.SameAs (selectProjection));
      Assert.That (testedBuilder.TopExpression, Is.SameAs (topExpression));
      Assert.That (testedBuilder.SqlTables[0], Is.SameAs (sqlTable));
      Assert.That (testedBuilder.Orderings[0], Is.SameAs (ordering));
      Assert.That (testedBuilder.WhereCondition, Is.EqualTo (whereCondition));
      Assert.That (testedBuilder.IsDistinctQuery, Is.EqualTo (isDistinctQuery));
      Assert.That (testedBuilder.DataInfo, Is.SameAs (sqlStatement.DataInfo));
      Assert.That (testedBuilder.RowNumberSelector, Is.SameAs (sqlStatement.RowNumberSelector));
      Assert.That (testedBuilder.CurrentRowNumberOffset, Is.SameAs (currentRowNumberOffset));
      Assert.That (testedBuilder.GroupByExpression, Is.SameAs (groupExpression));
    }
        private void ExpandCompositeOrderings(OrderByClause orderByClause)
        {
            var orderings = orderByClause.Orderings;
            var copy = new Ordering[orderings.Count];
            orderings.CopyTo(copy, 0);

            copy.Apply(o => orderings.Remove(o));

            foreach (var o in copy)
            {
                if (o.Expression is LuceneCompositeOrderingExpression)
                {
                    var ex = (LuceneCompositeOrderingExpression) o.Expression;

                    ex.Fields.Apply(f => orderings.Add(new Ordering(f, o.OrderingDirection)));
                }
                else
                {
                    orderings.Add(o);
                }
            }
        }
    public void ToString_AllProperties ()
    {
      var dataInfo = new TestStreamedValueInfo (typeof (int));
      var selectProjection = Expression.Constant (1);
      var sqlTable1 = new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner);
      var sqlTable2 = new SqlTable (new ResolvedSimpleTableInfo (typeof (Kitchen), "KitchenTable", "k"), JoinSemantics.Left);
      var ordering = new Ordering (Expression.Constant ("ordering"), OrderingDirection.Asc);
      var whereCondition = Expression.Constant (true);
      var topExpression = Expression.Constant (10);
      var groupExpression = Expression.Constant ("group");

      var builder = new SqlStatementBuilder
                    {
                        DataInfo = dataInfo,
                        SelectProjection = selectProjection,
                        SqlTables = { sqlTable1, sqlTable2 },
                        Orderings = { ordering },
                        WhereCondition = whereCondition,
                        TopExpression = topExpression,
                        IsDistinctQuery = true,
                        GroupByExpression = groupExpression
                    };

      var result = builder.ToString();

      Assert.That (
          result,
          Is.EqualTo (
              "SELECT DISTINCT TOP (10) 1 FROM [CookTable] [c], [KitchenTable] [k] WHERE True GROUP BY \"group\" ORDER BY \"ordering\" ASC"));
    }
    public void GetSqlStatement_CheckProperties ()
    {
      var dataInfo = new TestStreamedValueInfo (typeof (Cook));
      var topExpression = ExpressionHelper.CreateExpression();
      var isDistinctQuery = BooleanObjectMother.GetRandomBoolean();
      var selectProjection = new AggregationExpression (typeof (int), Expression.Constant (1), AggregationModifier.Min);
      var whereCondition = Expression.Constant (true);
      var sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner);
      var ordering = new Ordering (Expression.Constant ("order"), OrderingDirection.Desc);
      var rowNumberSelector = Expression.Constant ("selector");
      var currentRowNumberOffset = Expression.Constant (1);
      var groupExpression = Expression.Constant ("group");

      var statementBuilder = new SqlStatementBuilder
                             {
                                 DataInfo = dataInfo,
                                 TopExpression = topExpression,
                                 IsDistinctQuery = isDistinctQuery,
                                 SelectProjection = selectProjection,
                                 SqlTables = { sqlTable },
                                 WhereCondition = whereCondition,
                                 RowNumberSelector = rowNumberSelector,
                                 CurrentRowNumberOffset = currentRowNumberOffset,
                                 GroupByExpression = groupExpression,
                                 Orderings = { ordering }
                             };

      var sqlStatement = statementBuilder.GetSqlStatement();

      Assert.That (sqlStatement.DataInfo, Is.SameAs (dataInfo));
      Assert.That (sqlStatement.TopExpression, Is.SameAs (topExpression));
      Assert.That (sqlStatement.IsDistinctQuery, Is.EqualTo (isDistinctQuery));
      Assert.That (sqlStatement.SelectProjection, Is.SameAs (selectProjection));
      Assert.That (sqlStatement.SqlTables[0], Is.SameAs (sqlTable));
      Assert.That (sqlStatement.Orderings[0], Is.SameAs (ordering));
      Assert.That (sqlStatement.WhereCondition, Is.SameAs (whereCondition));
      Assert.That (sqlStatement.RowNumberSelector, Is.SameAs (rowNumberSelector));
      Assert.That (sqlStatement.CurrentRowNumberOffset, Is.SameAs (currentRowNumberOffset));
      Assert.That (sqlStatement.GroupByExpression, Is.SameAs (groupExpression));
    }
		public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
		{
			ordering.TransformExpressions(e => MergeAggregatingResultsInExpressionRewriter.Rewrite(e, new NameGenerator(queryModel)));
		}
		public void Transform(Ordering ordering)
		{
			ordering.TransformExpressions(VisitExpression);
		}
 /// <summary>
 ///     This API supports the Entity Framework Core infrastructure and is not intended to be used
 ///     directly from your code. This API may change or be removed in future releases.
 /// </summary>
 public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
     => ordering.TransformExpressions(TransformingVisitor.Visit);
Exemple #19
0
 public string ToOrderClause(Ordering clause)
 {
     var locator = _parser.JsonLocator(_mapping, clause.Expression);
     return clause.OrderingDirection == OrderingDirection.Asc
         ? locator
         : locator + " desc";
 }
    public void GenerateTextForOrdering (ISqlCommandBuilder commandBuilder, Ordering ordering)
    {
      ArgumentUtility.CheckNotNull ("commandBuilder", commandBuilder);
      ArgumentUtility.CheckNotNull ("ordering", ordering);
      
      if (ordering.Expression.NodeType == ExpressionType.Constant || ordering.Expression is SqlLiteralExpression)
      {
        commandBuilder.Append ("(SELECT ");
        GenerateTextForOrderByExpression (commandBuilder, ordering.Expression);
        commandBuilder.Append (")");
      }
      else
        GenerateTextForOrderByExpression (commandBuilder, ordering.Expression);

      commandBuilder.AppendFormat (string.Format (" {0}", ordering.OrderingDirection.ToString ().ToUpper ()));
    }
    public void VisitSqlStatement_EverthingIsCopiedIfSelectionProjectionHasChanged ()
    {
      var selectProjection = Expression.Constant("select");
      var whereCondition = Expression.Constant(true);
      var topExpression = Expression.Constant("top");
      var dataInfo = new StreamedSequenceInfo(typeof(Cook[]), Expression.Constant(new Cook()));
      var builder = new SqlStatementBuilder () 
      {  
        SelectProjection = selectProjection,
        WhereCondition = whereCondition,
        TopExpression = topExpression,
        IsDistinctQuery = true,
        DataInfo = dataInfo
      };
      var sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner);
      builder.SqlTables.Add (sqlTable);
      var ordering = new Ordering (Expression.Constant ("order"),OrderingDirection.Asc);
      builder.Orderings.Add (ordering);
      var sqlStatement = builder.GetSqlStatement();
      var fakeResult = Expression.Constant ("fake");

      _stageMock
          .Expect (mock => mock.ApplyContext (sqlStatement.SelectProjection, SqlExpressionContext.ValueRequired, _mappingResolutionContext))
          .Return (fakeResult);
      _stageMock.Replay ();

      var result = SqlContextSelectionAdjuster.ApplyContext (sqlStatement, SqlExpressionContext.ValueRequired, _stageMock, _mappingResolutionContext);

      _stageMock.VerifyAllExpectations();
      Assert.That (result.SelectProjection, Is.SameAs (fakeResult));
      Assert.That (result.DataInfo, Is.SameAs (dataInfo));
      Assert.That (result.WhereCondition, Is.SameAs (whereCondition));
      Assert.That (result.TopExpression, Is.SameAs (topExpression));
      Assert.That (result.SqlTables[0], Is.SameAs (sqlTable));
      Assert.That (result.Orderings[0], Is.SameAs (ordering));
      Assert.That (result.IsDistinctQuery, Is.True);
    }
    public void NumberExpression ()
    {
      var ordering1 = new Ordering (Expression.Constant ("order1"), OrderingDirection.Asc);
      var ordering2 = new Ordering (Expression.Constant ("order2"), OrderingDirection.Desc);
      var sqlRowNumberRÉxpression =
          new SqlRowNumberExpression (
              new[]
              {
                  ordering1,
                  ordering2
              });

      _stageMock
          .Expect (mock => mock.GenerateTextForOrdering (_commandBuilder, ordering1))
          .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("order1 ASC"));
      _stageMock
          .Expect (mock => mock.GenerateTextForOrdering (_commandBuilder, ordering2))
          .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("order2 DESC"));
      _stageMock.Replay();

      SqlGeneratingExpressionVisitor.GenerateSql (sqlRowNumberRÉxpression, _commandBuilder, _stageMock);

      _stageMock.VerifyAllExpectations();
      Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("ROW_NUMBER() OVER (ORDER BY order1 ASC, order2 DESC)"));
    }
        public override void VisitOrdering(
            Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
        {
            QueryBuildResult result = QueryBuildingVisitor.Build(ordering.Expression);
            PropertyExpression propExpr = result.Expression as PropertyExpression;
            OrderDirection direction = ordering.OrderingDirection == OrderingDirection.Asc
                                           ? OrderDirection.Ascending
                                           : OrderDirection.Descending;

            _orderByAggregator.Add(new OrderData(propExpr, direction));
            _returnProperties.AddRange(result.PropertiesUsed);

            base.VisitOrdering(ordering, queryModel, orderByClause, index);
        }
    public void BuildOrderBy_WithMultipleOrderByClauses ()
    {
      var columnExpression1 = new SqlColumnDefinitionExpression (typeof (string), "t", "ID", false);
      var orderByClause1 = new Ordering (columnExpression1, OrderingDirection.Asc);
      var columnExpression2 = new SqlColumnDefinitionExpression (typeof (string), "t", "Name", false);
      var orderByClause2 = new Ordering (columnExpression2, OrderingDirection.Desc);
      var columnExpression3 = new SqlColumnDefinitionExpression (typeof (string), "t", "City", false);
      var orderByClause3 = new Ordering (columnExpression3, OrderingDirection.Desc);

      var sqlStatement = new SqlStatement (
          new TestStreamedValueInfo (typeof (int)),
          _entityExpression,
          new[] { _sqlTable },
          null,
          null,
          new[] { orderByClause1, orderByClause2, orderByClause3 },
          null,
          false,
          null,
          null);

      _stageMock.Expect (mock => mock.GenerateTextForOrdering (_commandBuilder, sqlStatement.Orderings[0]))
          .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[ID] ASC"));
      _stageMock.Expect (mock => mock.GenerateTextForOrdering (_commandBuilder, sqlStatement.Orderings[1]))
          .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[Name] DESC"));
      _stageMock.Expect (mock => mock.GenerateTextForOrdering (_commandBuilder, sqlStatement.Orderings[2]))
          .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[City] DESC"));
      _stageMock.Replay();

      _generator.BuildOrderByPart (sqlStatement, _commandBuilder);

      Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo (" ORDER BY [t].[ID] ASC, [t].[Name] DESC, [t].[City] DESC"));
      _stageMock.VerifyAllExpectations();
    }
        private static Ordering UpdateColumnExpression(Ordering ordering, TableExpressionBase tableExpression)
        {
            var newExpression = UpdateColumnExpression(ordering.Expression, tableExpression);
            var newOrdering = new Ordering(newExpression, ordering.OrderingDirection);

            return newOrdering;
        }
    public void Build_WithOrderByClause ()
    {
      var columnExpression = new SqlColumnDefinitionExpression (typeof (string), "t", "Name", false);
      var orderByClause = new Ordering (columnExpression, OrderingDirection.Asc);

      var sqlStatement = new SqlStatement (
          new TestStreamedValueInfo (typeof (int)),
          _entityExpression,
          new[] { _sqlTable },
          null,
          null,
          new[] { orderByClause },
          null,
          false,
          null,
          null);

      _stageMock.Expect (
          mock => mock.GenerateTextForSelectExpression (_commandBuilder, sqlStatement.SelectProjection))
          .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[ID],[t].[Name],[t].[City]"));
      _stageMock.Expect (mock => mock.GenerateTextForFromTable (_commandBuilder, sqlStatement.SqlTables[0], true))
          .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[Table] AS [t]"));
      _stageMock.Expect (mock => mock.GenerateTextForOrdering (_commandBuilder, sqlStatement.Orderings[0]))
          .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[Name] ASC"));
      _stageMock.Replay();

      _generator.Build (sqlStatement, _commandBuilder, false);

      _commandBuilder.SetInMemoryProjectionBody (Expression.Constant (0));
      var result = _commandBuilder.GetCommand();

      Assert.That (result.CommandText, Is.EqualTo ("SELECT [t].[ID],[t].[Name],[t].[City] FROM [Table] AS [t] ORDER BY [t].[Name] ASC"));
      _stageMock.VerifyAllExpectations();
    }
        public virtual void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
        {
            ArgumentUtility.CheckNotNull ("ordering", ordering);
              ArgumentUtility.CheckNotNull ("queryModel", queryModel);
              ArgumentUtility.CheckNotNull ("orderByClause", orderByClause);

              // nothing to do here
        }
 private FromExpressionInfo CreateFakeFromExpressionInfo (Ordering[] extractedOrderings)
 {
   return new FromExpressionInfo (
       new SqlTable (new ResolvedSubStatementTableInfo("sc", _statementBuilder.GetSqlStatement()), JoinSemantics.Inner),
       extractedOrderings,
       Expression.Constant (0),
       null);
 }
		public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
		{
			_resultOperatorAndOrderByJoinDetector.Transform(ordering);
		}
    public void MoveCurrentStatementToSqlTable_WithOrderings ()
    {
      var ordering = new Ordering (Expression.Constant ("order1"), OrderingDirection.Desc);

      var fakeFromExpressionInfo = CreateFakeFromExpressionInfo (new[] { ordering });

      _stageMock
          .Expect (
              mock => mock.PrepareFromExpression (Arg<Expression>.Is.Anything, Arg<ISqlPreparationContext>.Is.Anything, Arg<Func<ITableInfo, SqlTable>>.Is.Anything))
          .Return (fakeFromExpressionInfo);
      _stageMock.Replay ();

      _handler.MoveCurrentStatementToSqlTable (_statementBuilder, _generator, _context, info => new SqlTable (info, JoinSemantics.Inner), _stageMock);

      Assert.That (_statementBuilder.Orderings[0], Is.SameAs (ordering));
    }