public virtual void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
ArgumentUtility.CheckNotNull ("orderByClause", orderByClause);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
VisitOrderings (orderByClause.Orderings, queryModel, orderByClause);
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
foreach (var ordering in orderByClause.Orderings)
{
model.AddSort(ordering.Expression, ordering.OrderingDirection);
}
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitOrdering"/> method.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
/// <param name="orderByClause">The <see cref="OrderByClause"/> in whose context this item is visited.</param>
/// <param name="index">The index of this item in the <paramref name="orderByClause"/>'s <see cref="OrderByClause.Orderings"/> collection.</param>
public virtual void Accept (IQueryModelVisitor visitor, QueryModel queryModel, OrderByClause orderByClause, int index)
{
ArgumentUtility.CheckNotNull ("visitor", visitor);
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
ArgumentUtility.CheckNotNull ("orderByClause", orderByClause);
visitor.VisitOrdering (this, queryModel, orderByClause, index);
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
var joinDetector = new SelectAndOrderByJoinDetector(_nameGenerator, this, _joins, _expressionMap);
foreach (Ordering ordering in orderByClause.Orderings)
{
joinDetector.VisitExpression(ordering.Expression);
}
}
protected override void ApplyNodeSpecificSemantics (QueryModel queryModel, ClauseGenerationContext clauseGenerationContext)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
var clause = new OrderByClause();
clause.Orderings.Add (new Ordering (GetResolvedKeySelector (clauseGenerationContext), OrderingDirection.Desc));
queryModel.BodyClauses.Add (clause);
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
var visitor = new EnigmaExpressionTreeVisitor(_objectExpression);
foreach (var ordering in orderByClause.Orderings) {
visitor.VisitExpression(ordering.Expression);
_objectExpression.OrderBy(ordering.OrderingDirection);
}
base.VisitOrderByClause(orderByClause, queryModel, index);
}
public void ConvertsToSort_Desc()
{
var orderByClause = new OrderByClause();
orderByClause.Orderings.Add(new Ordering(new LuceneQueryFieldExpression(typeof(string), "Name"), OrderingDirection.Desc));
ExpectSortOnProperty("Name", SortField.STRING, OrderingDirection.Desc);
transformer.VisitOrderByClause(orderByClause, queryModel, 0);
Assert.That(transformer.Model.Sort.GetSort().Length, Is.EqualTo(1));
AssertSortFieldEquals(transformer.Model.Sort.GetSort()[0], "Name", OrderingDirection.Desc, SortField.STRING);
}
public void ConvertsDateTimeOffsetToSort()
{
var orderByClause = new OrderByClause();
orderByClause.Orderings.Add(new Ordering(new LuceneQueryFieldExpression(typeof(DateTimeOffset?), "Date"), OrderingDirection.Asc));
ExpectSortOnProperty("Date", SortField.LONG, OrderingDirection.Asc);
transformer.VisitOrderByClause(orderByClause, queryModel, 0);
Assert.That(transformer.Model.Sort.GetSort().Length, Is.EqualTo(1));
AssertSortFieldEquals(transformer.Model.Sort.GetSort()[0], "Date", OrderingDirection.Asc, SortField.LONG);
}
public void ConvertsDateTimeToSortNonNumeric()
{
var orderByClause = new OrderByClause();
orderByClause.Orderings.Add(new Ordering(new LuceneQueryFieldExpression(typeof(DateTimeOffset?), "Date"), OrderingDirection.Asc));
mappingInfo.Expect(m => m.GetMappingInfo("Date")).Return(nonNumericMappingInfo);
nonNumericMappingInfo.Stub(i => i.FieldName).Return("Date");
transformer.VisitOrderByClause(orderByClause, queryModel, 0);
Assert.That(transformer.Model.Sort.GetSort().Length, Is.EqualTo(1));
AssertSortFieldEquals(transformer.Model.Sort.GetSort()[0], "Date", OrderingDirection.Asc, SortField.STRING);
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
foreach (var clause in orderByClause.Orderings)
{
var orderBy = HqlGeneratorExpressionVisitor.Visit(clause.Expression, VisitorParameters).ToArithmeticExpression();
var direction = clause.OrderingDirection == OrderingDirection.Asc
? _hqlTree.TreeBuilder.Ascending()
: (HqlDirectionStatement)_hqlTree.TreeBuilder.Descending();
_hqlTree.AddOrderByClause(orderBy, direction);
}
}
public void Apply ()
{
var clause = new OrderByClause ();
QueryModel.BodyClauses.Add (clause);
var result = _node.Apply (QueryModel, ClauseGenerationContext);
Assert.That (result, Is.SameAs (QueryModel));
Assert.That (clause.Orderings.Count, Is.EqualTo (1));
Assert.That (clause.Orderings[0].OrderingDirection, Is.EqualTo (OrderingDirection.Asc));
Assert.That (clause.Orderings[0].Expression, Is.SameAs (_node.GetResolvedKeySelector (ClauseGenerationContext)));
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
Log.Trace(m => m("Original QueryModel: {0}", queryModel));
foreach (var visitor in orderingVisitors)
{
orderByClause.TransformExpressions(visitor.VisitExpression);
Log.Trace(m => m("Transformed QueryModel after {0}: {1}", visitor.GetType().Name, queryModel));
}
ExpandCompositeOrderings(orderByClause);
base.VisitOrderByClause(orderByClause, queryModel, index);
}
/// <summary>
/// 解析 orderby 语句
/// </summary>
/// <param name="orderByClause"></param>
/// <param name="queryModel"></param>
/// <param name="index"></param>
public override void VisitOrderByClause( OrderByClause orderByClause, QueryModel queryModel, int index )
{
foreach( var ordering in orderByClause.Orderings )
{
MySqlOrderByClauseVisitor visitor = new MySqlOrderByClauseVisitor( this.parameterAggregator );
string orderByParts = visitor.Translate( ordering.Expression );
string direction = ordering.OrderingDirection == OrderingDirection.Desc ? "DESC" : "ASC";
queryPartsAggregator.OrderByParts.Add( string.Format( "{0} {1}", orderByParts, direction ) );
}
base.VisitOrderByClause( orderByClause, queryModel, index );
}
public void SetUp ()
{
_generator = new UniqueIdentifierGenerator();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_defaultStage = new DefaultSqlPreparationStage (
CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), _generator);
_mainFromClause = ExpressionHelper.CreateMainFromClause<Cook>();
_selectClause = ExpressionHelper.CreateSelectClause (_mainFromClause);
_orderByClause = ExpressionHelper.CreateOrderByClause();
_queryModel = new QueryModel (_mainFromClause, _selectClause);
_stageMock = MockRepository.GenerateStrictMock<ISqlPreparationStage>();
_visitor = new TestableSqlPreparationQueryModelVisitor (_context, _stageMock);
_visitorPartialMock = MockRepository.GeneratePartialMock<TestableSqlPreparationQueryModelVisitor> (_context, _stageMock);
}
/// <summary>
/// 解析 orderby 语句
/// </summary>
/// <param name="orderByClause"></param>
/// <param name="queryModel"></param>
/// <param name="index"></param>
public override void VisitOrderByClause( OrderByClause orderByClause, QueryModel queryModel, int index )
{
foreach( var ordering in orderByClause.Orderings )
{
OracleOrderByPartsCommandBuilder orderBuilder = new OracleOrderByPartsCommandBuilder();
OracleOrderByClauseVisitor visitor = new OracleOrderByClauseVisitor();
visitor.Translate( ordering.Expression, orderBuilder );
string direction = ordering.OrderingDirection == OrderingDirection.Desc ? "desc" : "asc";
commandBuilder.OrderByParts.Add( string.Format( "{0} {1}", orderBuilder.ToString(), direction ) );
}
base.VisitOrderByClause( orderByClause, queryModel, index );
}
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 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 AddOrderBy(OrderByClause orderBy)
{
OrderBy.Add(orderBy);
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
QueryParts.AddOrderBy(orderByClause);
base.VisitOrderByClause(orderByClause, queryModel, index);
}
public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
{
_resultOperatorAndOrderByJoinDetector.Transform(ordering);
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
base.VisitOrderByClause(orderByClause, queryModel, index);
}
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
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitOrdering"/> method.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
/// <param name="orderByClause">The <see cref="OrderByClause"/> in whose context this item is visited.</param>
/// <param name="index">The index of this item in the <paramref name="orderByClause"/>'s <see cref="OrderByClause.Orderings"/> collection.</param>
public virtual void Accept(IQueryModelVisitor visitor, QueryModel queryModel, OrderByClause orderByClause, int index)
{
ArgumentUtility.CheckNotNull("visitor", visitor);
ArgumentUtility.CheckNotNull("queryModel", queryModel);
ArgumentUtility.CheckNotNull("orderByClause", orderByClause);
visitor.VisitOrdering(this, queryModel, orderByClause, index);
}
protected virtual void VisitOrderings(ObservableCollection<Ordering> orderings, QueryModel queryModel, OrderByClause orderByClause)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
ArgumentUtility.CheckNotNull ("orderByClause", orderByClause);
ArgumentUtility.CheckNotNull ("orderings", orderings);
foreach (var indexValuePair in orderings.AsChangeResistantEnumerableWithIndex())
indexValuePair.Value.Accept (this, queryModel, orderByClause, indexValuePair.Index);
}
/// <summary>
/// Doing ordering of the clause, are we?
/// </summary>
/// <param name="orderByClause"></param>
/// <param name="queryModel"></param>
/// <param name="index"></param>
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
base.VisitOrderByClause(orderByClause, queryModel, index);
foreach (var expr in orderByClause.Orderings.Select(o => o.Expression))
{
_exprVisitor.Visit(expr);
}
}
/// <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);
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
foreach (var clause in orderByClause.Orderings)
{
_hqlTree.AddOrderByClause(HqlGeneratorExpressionTreeVisitor.Visit(clause.Expression, VisitorParameters).AsExpression(),
clause.OrderingDirection == OrderingDirection.Asc
? _hqlTree.TreeBuilder.Ascending()
: (HqlDirectionStatement)_hqlTree.TreeBuilder.Descending());
}
}
public override void VisitOrderByClause( OrderByClause orderByClause, QueryModel queryModel, int index )
{
var expression = orderByClause.Orderings[0].Expression as MemberExpression;
if( expression == null )
return;
OrderBy reql;
var currentStack = Stack.Pop();
if( orderByClause.Orderings[0].OrderingDirection == OrderingDirection.Asc )
reql = currentStack.OrderBy( expression.Member.Name );
else
reql = currentStack.OrderBy( RethinkDB.R.Desc( expression.Member.Name ) );
if( currentStack is Table && expression.Member.CustomAttributes.Any( x => x.AttributeType == typeof( PrimaryIndexAttribute ) || x.AttributeType == typeof( SecondaryIndexAttribute ) ) )
reql = reql.OptArg( "index", expression.Member.Name );
Stack.Push( reql );
}
protected override void VisitOrderings(ObservableCollection<Ordering> orderings, QueryModel queryModel, OrderByClause orderByClause)
{
var orders = orderings.SelectMany(ordering => PropertyPathExtractionVisitor.ExtractPaths(ordering.Expression, _nodeTypeProvider, false, true, _namingScheme, ".")
.Select(path => string.Format("{0} {1}", path, ordering.OrderingDirection.ToString().ToLowerInvariant())))
.ToList();
if (orders.Count > 0)
{
if (OrderBy != null)
{
OrderBy = "," + OrderBy;
}
OrderBy = string.Join(",", orders.ToArray()) + OrderBy;
}
base.VisitOrderings(orderings, queryModel, orderByClause);
}
/// <summary>
/// Accepts the specified visitor by calling its <see cref="IQueryModelVisitor.VisitOrdering"/> method.
/// </summary>
/// <param name="visitor">The visitor to accept.</param>
/// <param name="queryModel">The query model in whose context this clause is visited.</param>
/// <param name="orderByClause">The <see cref="OrderByClause"/> in whose context this item is visited.</param>
/// <param name="index">The index of this item in the <paramref name="orderByClause"/>'s <see cref="OrderByClause.Orderings"/> collection.</param>
public virtual void Accept(IQueryModelVisitor visitor, QueryModel queryModel, OrderByClause orderByClause, int index)
{
visitor.VisitOrdering(this, queryModel, orderByClause, index);
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
var orderByParts =
orderByClause.Orderings.Select(
ordering =>
String.Concat(GetN1QlExpression(ordering.Expression), " ",
ordering.OrderingDirection.ToString().ToUpper())).ToList();
_queryPartsAggregator.AddOrderByPart(orderByParts);
base.VisitOrderByClause(orderByClause, queryModel, index);
}
public void Apply_UsesLastClause ()
{
var clause = new OrderByClause ();
QueryModel.BodyClauses.Add (new OrderByClause ());
QueryModel.BodyClauses.Add (clause);
_node.Apply (QueryModel, ClauseGenerationContext);
Assert.That (clause.Orderings.Count, Is.EqualTo (1));
}