/// <summary> /// Initializes a new instance of the <see cref="Ordering"/> class. /// </summary> /// <param name="expression">The expression used to order the data items returned by the query.</param> /// <param name="direction">The <see cref="OrderingDirection"/> to use for sorting.</param> public Ordering (Expression expression, OrderingDirection direction) { ArgumentUtility.CheckNotNull ("expression", expression); _expression = expression; OrderingDirection = direction; }
public virtual AliasExpression AddToOrderBy( [NotNull] string column, [NotNull] IProperty property, [NotNull] TableExpressionBase table, OrderingDirection orderingDirection) { Check.NotEmpty(column, nameof(column)); Check.NotNull(property, nameof(property)); Check.NotNull(table, nameof(table)); var columnExpression = new ColumnExpression(column, property, table); var aliasExpression = new AliasExpression(columnExpression); if (_orderBy.FindIndex(o => o.Expression.TryGetColumnExpression()?.Equals(columnExpression) ?? false) == -1) { _orderBy.Add(new Ordering(aliasExpression, orderingDirection)); } return(aliasExpression); }
public virtual ColumnExpression AddToOrderBy( [NotNull] string column, [NotNull] IProperty property, [NotNull] IQuerySource querySource, OrderingDirection orderingDirection) { Check.NotEmpty(column, "column"); Check.NotNull(property, "property"); Check.NotNull(property, "querySource"); var columnExpression = new ColumnExpression( column, property, FindTableForQuerySource(querySource)); if (_orderBy.FindIndex(o => o.Expression.Equals(columnExpression)) == -1) { _orderBy.Add(new Ordering(columnExpression, orderingDirection)); } return(columnExpression); }
public virtual void AddToOrderBy([NotNull] IProperty property, OrderingDirection orderingDirection) { Check.NotNull(property, "property"); _orderByList.Add(Tuple.Create(property, orderingDirection)); }
public static string GetStatement(Parameters parameters, Expression expression, OrderingDirection orderingDirection) { var expressionVisitor = new OrderByExpressionVisitor(parameters); expressionVisitor.VisitExpression(expression); if (orderingDirection == OrderingDirection.Desc) { expressionVisitor.Statement.Append(" desc"); } return(expressionVisitor.GetStatement()); }
private static IOrderedAsyncEnumerable <TSource> ThenByShim <TSource, TKey>( IOrderedAsyncEnumerable <TSource> source, Func <TSource, TKey> expression, OrderingDirection orderingDirection) { return(orderingDirection == OrderingDirection.Asc ? source.ThenBy(expression) : source.ThenByDescending(expression)); }
public void OrderBy(PropertyPath path, OrderingDirection direction) { _orderings.Add(new EmbeddedIndexOrdering(path, direction)); }
/// <summary> /// Create a new ordering clause /// </summary> /// <param name="selectorExpression">The expression used for sorting</param> /// <param name="orderingDirection">The sort direction</param> public SparqlOrdering(string selectorExpression, OrderingDirection orderingDirection) { SelectorExpression = selectorExpression; OrderingDirection = orderingDirection; }
private void ExpectSortOnProperty(string propertyName, int sortType, OrderingDirection direction) { var mappingInfo = MockRepository.GenerateStub<IFieldMappingInfo>(); mappingProvider.Expect(m => m.GetMappingInfo(propertyName)).Return(mappingInfo); mappingInfo.Stub(i => i.FieldName).Return(propertyName); mappingInfo.Stub(i => i.CreateSortField(direction == OrderingDirection.Desc)).Return(new SortField(propertyName, sortType, direction == OrderingDirection.Desc)); }
internal void Parse(Ordering ordering) { direction = ordering.OrderingDirection; Visit(ordering.Expression); }
public virtual ColumnExpression AddToOrderBy( [NotNull] IProperty property, [NotNull] IQuerySource querySource, OrderingDirection orderingDirection) { Check.NotNull(property, "property"); Check.NotNull(property, "querySource"); var columnExpression = new ColumnExpression(property, FindTableForQuerySource(querySource).Alias); _orderBy.Add(new Ordering(columnExpression, orderingDirection)); return columnExpression; }
private void AssertSortFieldEquals(SortField sortField, string expectedFieldName, OrderingDirection expectedDirection, int expectedType) { Assert.That(sortField.Field, Is.EqualTo(expectedFieldName)); Assert.That(sortField.Type, Is.EqualTo(expectedType), "SortField type for field " + expectedFieldName); Assert.That(sortField.Reverse, Is.EqualTo(expectedDirection == OrderingDirection.Desc), "Reverse"); }
/// <summary> /// Initializes a new instance of the <see cref="Ordering"/> class. /// </summary> /// <param name="expression">The expression used to order the data items returned by the query.</param> /// <param name="direction">The <see cref="OrderingDirection"/> to use for sorting.</param> public Ordering(Expression expression, OrderingDirection direction) { _expression = expression; OrderingDirection = direction; }
public static IQueryable <TSource> OrderByWithDirection <TSource, TKey>(this IQueryable <TSource> query, Expression <Func <TSource, TKey> > keySelector, OrderingDirection direction) => direction switch {
internal static IOrderedEnumerable <TSource> _OrderBy <TSource, TKey>( IEnumerable <TSource> source, Func <TSource, TKey> expression, OrderingDirection orderingDirection) => orderingDirection == OrderingDirection.Asc ? source.OrderBy(expression) : source.OrderByDescending(expression);
public virtual AliasExpression AddToOrderBy( [NotNull] string column, [NotNull] IProperty property, [NotNull] TableExpressionBase table, OrderingDirection orderingDirection) { Check.NotEmpty(column, nameof(column)); Check.NotNull(property, nameof(property)); Check.NotNull(table, nameof(table)); var columnExpression = new ColumnExpression(column, property, table); var aliasExpression = new AliasExpression(columnExpression); if (_orderBy.FindIndex(o => o.Expression.TryGetColumnExpression()?.Equals(columnExpression) ?? false) == -1) { _orderBy.Add(new Ordering(aliasExpression, orderingDirection)); } return aliasExpression; }
// ReSharper disable once InconsistentNaming private static IOrderedEnumerable <TSource> _ThenBy <TSource, TKey>( IOrderedEnumerable <TSource> source, Func <TSource, TKey> expression, OrderingDirection orderingDirection) => orderingDirection == OrderingDirection.Asc ? source.ThenBy(expression) : source.ThenByDescending(expression);
public OrderProperties(string propertyName, Type propertyType, OrderingDirection direction) { PropertyType = propertyType; PropertyName = propertyName; OrderingDirection = direction; }
public OrderingExpression(PropertyPath path, Expression expression, OrderingDirection direction) { _path = path; _expression = expression; _direction = direction; }
public static string GetStatement(DataContext dbContext, SqlParameterCollection parameters, Expression expression, OrderingDirection orderingDirection) { var expressionVisitor = new OrderByExpressionVisitor(dbContext, parameters); expressionVisitor.Visit(expression); if (orderingDirection == OrderingDirection.Desc) { expressionVisitor.Statement.Append(" desc"); } return(expressionVisitor.GetStatement()); }
public EmbeddedIndexOrdering(PropertyPath path, OrderingDirection direction) { _path = path; _direction = direction; }