/// <summary>
/// Creates a list of <see cref="OrderByPropertyNode"/> instances from a linked list of <see cref="OrderByClause"/> instances.
/// </summary>
/// <param name="orderByClause">The head of the <see cref="OrderByClause"/> linked list.</param>
/// <returns>The list of new <see cref="OrderByPropertyNode"/> instances.</returns>
public static IList<OrderByNode> CreateCollection(OrderByClause orderByClause)
{
List<OrderByNode> result = new List<OrderByNode>();
for (OrderByClause clause = orderByClause; clause != null; clause = clause.ThenBy)
{
if (clause.Expression is NonentityRangeVariableReferenceNode || clause.Expression is EntityRangeVariableReferenceNode)
{
result.Add(new OrderByItNode(clause.Direction));
}
else
{
SingleValuePropertyAccessNode property = clause.Expression as SingleValuePropertyAccessNode;
if (property == null ||
!(property.Source is EntityRangeVariableReferenceNode || property.Source is NonentityRangeVariableReferenceNode))
{
throw new ODataException(SRResources.OrderByClauseNotSupported);
}
result.Add(new OrderByPropertyNode(property.Property, clause.Direction));
}
}
return result;
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
foreach (Ordering ordering in orderByClause.Orderings)
{
ordering.Expression = JoinReplacer(queryModel, ordering.Expression);
}
}
public void Process(OrderByClause OrderClause)
{
if (OrderClause == null) return;
foreach (ExpressionWithSortOrder Expression in OrderClause.OrderByElements)
{
ProcessOrderExpression(Expression);
}
}
private bool TryApplyOrderByClause(OrderByClause clause, QueryCommand cmd)
{
if (cmd.SkipCount.HasValue || cmd.TakeCount.HasValue)
return false;
cmd.Order.Add(new SimpleOrderByItem(clause.Reference, clause.Direction));
return true;
}
private bool TryApplyOrderByClause(OrderByClause clause)
{
if (SkipCount.HasValue || TakeCount.HasValue)
return false;
_order.Add(new SimpleOrderByItem(clause.Reference, clause.Direction));
return true;
}
public void Visit(OrderByClause order_by_clause)
{
_Query.Append("ORDER BY ");
foreach(Column column in order_by_clause)
{
column.Accept(this);
if (order_by_clause.IndexOf(column) != order_by_clause.Count -1 )
_Query.Append(", ");
}
}
/// <summary>
/// Initializes a query expression ast node.
/// </summary>
/// <param name="selectClause">select clause</param>
/// <param name="fromClause">from clasuse</param>
/// <param name="whereClause">optional where clause</param>
/// <param name="groupByClause">optional group by clause</param>
/// <param name="havingClause">optional having clause</param>
/// <param name="orderByClause">optional order by clause</param>
internal QueryExpr(
SelectClause selectClause,
FromClause fromClause,
Node whereClause,
GroupByClause groupByClause,
HavingClause havingClause,
OrderByClause orderByClause)
{
_selectClause = selectClause;
_fromClause = fromClause;
_whereClause = whereClause;
_groupByClause = groupByClause;
_havingClause = havingClause;
_orderByClause = orderByClause;
}
public void Ctor_TakingOrderByClause_InitializesProperty_Property()
{
// Arrange
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
IEdmProperty property = model.Customer.FindProperty("ID");
EntityRangeVariable variable = new EntityRangeVariable("it", model.Customer.AsReference(), model.Customers);
SingleValuePropertyAccessNode node = new SingleValuePropertyAccessNode(new EntityRangeVariableReferenceNode("it", variable), property);
OrderByClause orderBy = new OrderByClause(thenBy: null, expression: node, direction: OrderByDirection.Ascending, rangeVariable: variable);
// Act
OrderByPropertyNode orderByNode = new OrderByPropertyNode(orderBy);
// Assert
Assert.Equal(property, orderByNode.Property);
}
/// <summary>
/// Creates a collection of <see cref="OrderByPropertyNode"/> instances from a linked list of <see cref="OrderByClause"/> instances.
/// </summary>
/// <param name="orderByClause">The head of the <see cref="OrderByClause"/> linked list.</param>
/// <returns>The collection of new <see cref="OrderByPropertyNode"/> instances.</returns>
public static ICollection<OrderByPropertyNode> CreateCollection(OrderByClause orderByClause)
{
LinkedList<OrderByPropertyNode> result = new LinkedList<OrderByPropertyNode>();
for (OrderByClause clause = orderByClause; clause != null; clause = clause.ThenBy)
{
SingleValuePropertyAccessNode property = clause.Expression as SingleValuePropertyAccessNode;
if (property == null)
{
throw new ODataException(SRResources.OrderByPropertyNotFound);
}
result.AddLast(new OrderByPropertyNode(property.Property, clause.Direction));
}
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="OrderByPropertyNode"/> class.
/// </summary>
/// <param name="orderByClause">The orderby clause representing property access.</param>
public OrderByPropertyNode(OrderByClause orderByClause)
{
if (orderByClause == null)
{
throw Error.ArgumentNull("orderByClause");
}
OrderByClause = orderByClause;
Direction = orderByClause.Direction;
SingleValuePropertyAccessNode propertyExpression = orderByClause.Expression as SingleValuePropertyAccessNode;
if (propertyExpression == null)
{
throw new ODataException(SRResources.OrderByClauseNotSupported);
}
Property = propertyExpression.Property;
}
/// <summary>
/// Creates a list of <see cref="OrderByNode"/> instances from a linked list of <see cref="OrderByClause"/> instances.
/// </summary>
/// <param name="orderByClause">The head of the <see cref="OrderByClause"/> linked list.</param>
/// <returns>The list of new <see cref="OrderByPropertyNode"/> instances.</returns>
public static IList<OrderByNode> CreateCollection(OrderByClause orderByClause)
{
List<OrderByNode> result = new List<OrderByNode>();
for (OrderByClause clause = orderByClause; clause != null; clause = clause.ThenBy)
{
if (clause.Expression is NonentityRangeVariableReferenceNode || clause.Expression is EntityRangeVariableReferenceNode)
{
result.Add(new OrderByItNode(clause.Direction));
}
else
{
result.Add(new OrderByPropertyNode(clause));
}
}
return result;
}
public override void ExplicitVisit(OrderByClause fragment)
{
_fragments.Add(fragment);
}
public OrderByClauseHandler(OrderByClause orderByClause)
{
_orderByClause = orderByClause;
}
public static OeSkipTokenNameValue[] CreateNameValues(IEdmModel edmModel, OrderByClause uniqueOrderBy, String skipToken)
{
return(skipToken == null?Array.Empty <OeSkipTokenNameValue>() : ParseSkipToken(edmModel, uniqueOrderBy, skipToken));
}
internal static OrderByClause GetUniqueOrderBy(IEdmModel edmModel, IEdmEntitySet entitySet, OrderByClause orderByClause, ApplyClause applyClause)
{
if (orderByClause != null && applyClause == null && GetIsKey(entitySet.EntityType(), GetEdmProperies(orderByClause)))
{
return(orderByClause);
}
List <SingleValuePropertyAccessNode> orderByProperties = GetOrderByProperties(edmModel, entitySet, orderByClause, applyClause);
if (orderByProperties.Count == 0)
{
return(orderByClause ?? throw new InvalidOperationException("orderByClause must not null"));
}
OrderByClause uniqueOrderByClause = null;
for (int i = orderByProperties.Count - 1; i >= 0; i--)
{
ResourceRangeVariableReferenceNode source;
if (orderByProperties[i].Source is SingleNavigationNode navigationNode)
{
source = (ResourceRangeVariableReferenceNode)navigationNode.Source;
}
else
{
source = (ResourceRangeVariableReferenceNode)orderByProperties[i].Source;
}
uniqueOrderByClause = new OrderByClause(uniqueOrderByClause, orderByProperties[i], OrderByDirection.Ascending, source.RangeVariable);
}
if (orderByClause == null)
{
return(uniqueOrderByClause);
}
var orderByClauses = new Stack <OrderByClause>();
do
{
orderByClauses.Push(orderByClause);
orderByClause = orderByClause.ThenBy;
}while (orderByClause != null);
while (orderByClauses.Count > 0)
{
orderByClause = orderByClauses.Pop();
uniqueOrderByClause = new OrderByClause(uniqueOrderByClause, orderByClause.Expression, orderByClause.Direction, orderByClause.RangeVariable);
}
return(uniqueOrderByClause);
}
private static LambdaExpression BindOrderByClause(FilterBinder binder, OrderByClause orderBy, Type elementType)
{
LambdaExpression orderByLambda = binder.BindExpression(orderBy.Expression, orderBy.RangeVariable, elementType);
return(orderByLambda);
}
/// <summary>
/// Generate an expand item (and a select item for the implicit nav prop if necessary) based on an ExpandTermToken
/// </summary>
/// <param name="tokenIn">the expandTerm token to visit</param>
/// <returns>the expand item for this expand term token.</returns>
private ExpandedNavigationSelectItem GenerateExpandItem(ExpandTermToken tokenIn)
{
ExceptionUtils.CheckArgumentNotNull(tokenIn, "tokenIn");
// ensure that we're always dealing with proper V4 syntax
if (tokenIn.PathToNavProp.NextToken != null && !tokenIn.PathToNavProp.IsNamespaceOrContainerQualified())
{
throw new ODataException(ODataErrorStrings.ExpandItemBinder_TraversingMultipleNavPropsInTheSamePath);
}
PathSegmentToken currentToken = tokenIn.PathToNavProp;
IEdmStructuredType currentLevelEntityType = this.EdmType;
List <ODataPathSegment> pathSoFar = new List <ODataPathSegment>();
PathSegmentToken firstNonTypeToken = currentToken;
if (currentToken.IsNamespaceOrContainerQualified())
{
pathSoFar.AddRange(SelectExpandPathBinder.FollowTypeSegments(currentToken, this.Model, this.Settings.SelectExpandLimit, this.configuration.Resolver, ref currentLevelEntityType, out firstNonTypeToken));
}
IEdmProperty edmProperty = this.configuration.Resolver.ResolveProperty(currentLevelEntityType, firstNonTypeToken.Identifier);
if (edmProperty == null)
{
throw new ODataException(ODataErrorStrings.MetadataBinder_PropertyNotDeclared(currentLevelEntityType.ODataFullName(), currentToken.Identifier));
}
IEdmNavigationProperty currentNavProp = edmProperty as IEdmNavigationProperty;
if (currentNavProp == null)
{
throw new ODataException(ODataErrorStrings.ExpandItemBinder_PropertyIsNotANavigationProperty(currentToken.Identifier, currentLevelEntityType.ODataFullName()));
}
if (firstNonTypeToken.NextToken != null)
{
// lastly... make sure that, since we're on a NavProp, that the next token isn't null.
throw new ODataException(ODataErrorStrings.ExpandItemBinder_TraversingMultipleNavPropsInTheSamePath);
}
pathSoFar.Add(new NavigationPropertySegment(currentNavProp, /*entitySet*/ null));
ODataExpandPath pathToNavProp = new ODataExpandPath(pathSoFar);
SelectExpandClause subSelectExpand;
if (tokenIn.ExpandOption != null)
{
subSelectExpand = this.GenerateSubExpand(currentNavProp, tokenIn);
}
else
{
subSelectExpand = BuildDefaultSubExpand();
}
subSelectExpand = this.DecorateExpandWithSelect(subSelectExpand, currentNavProp, tokenIn.SelectOption);
IEdmNavigationSource targetNavigationSource = null;
if (this.NavigationSource != null)
{
targetNavigationSource = this.NavigationSource.FindNavigationTarget(currentNavProp);
}
// call MetadataBinder to build the filter clause
FilterClause filterOption = null;
if (tokenIn.FilterOption != null)
{
MetadataBinder binder = this.BuildNewMetadataBinder(targetNavigationSource);
FilterBinder filterBinder = new FilterBinder(binder.Bind, binder.BindingState);
filterOption = filterBinder.BindFilter(tokenIn.FilterOption);
}
// call MetadataBinder again to build the orderby clause
OrderByClause orderbyOption = null;
if (tokenIn.OrderByOptions != null)
{
MetadataBinder binder = this.BuildNewMetadataBinder(targetNavigationSource);
OrderByBinder orderByBinder = new OrderByBinder(binder.Bind);
orderbyOption = orderByBinder.BindOrderBy(binder.BindingState, tokenIn.OrderByOptions);
}
LevelsClause levelsOption = this.ParseLevels(tokenIn.LevelsOption, currentLevelEntityType, currentNavProp);
SearchClause searchOption = null;
if (tokenIn.SearchOption != null)
{
MetadataBinder binder = this.BuildNewMetadataBinder(targetNavigationSource);
SearchBinder searchBinder = new SearchBinder(binder.Bind);
searchOption = searchBinder.BindSearch(tokenIn.SearchOption);
}
return(new ExpandedNavigationSelectItem(pathToNavProp, targetNavigationSource, subSelectExpand, filterOption, orderbyOption, tokenIn.TopOption, tokenIn.SkipOption, tokenIn.CountQueryOption, searchOption, levelsOption));
}
/// <summary>
/// 验证
/// </summary>
public virtual void Validate()
{
FromClause.Validate();
OrderByClause.Validate(_pager);
}
public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
{
base.VisitOrdering(ordering, queryModel, orderByClause, index);
TransformingVisitor.StringBuilder.Append($" {ordering.OrderingDirection.ToString().ToLower()}");
}
public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
{
_expander.Transform(ordering);
}
public Expression Build(Expression source, IReadOnlyList <OeSkipTokenNameValue> skipTokenNameValues, OrderByClause uniqueOrderBy)
{
OrderProperty[] orderProperties = CreateOrderProperies(source, _visitor, skipTokenNameValues, uniqueOrderBy);
Expression filter = CreateFilterExpression(_visitor, _isDatabaseNullHighestValue, orderProperties);
LambdaExpression lambda = Expression.Lambda(filter, _visitor.Parameter);
MethodInfo whereMethodInfo = OeMethodInfoHelper.GetWhereMethodInfo(_visitor.Parameter.Type);
return(Expression.Call(whereMethodInfo, source, lambda));
}
protected virtual string GetClauseSql (OrderByClause clause)
{
throw new NotImplementedException ();
}
public static Expression BuildNested(OeJoinBuilder joinBuilder, Expression source, ParameterExpression parameterExpression, OrderByClause orderByClause,
IReadOnlyList <IEdmNavigationProperty> joinPath)
{
while (orderByClause != null)
{
var propertyNode = (SingleValuePropertyAccessNode)orderByClause.Expression;
Expression?keySelector = joinBuilder.GetJoinPropertyExpression(source, joinBuilder.Visitor.Parameter, joinPath, propertyNode.Property);
if (keySelector == null)
{
throw new InvalidOperationException("Sorting EdmProperty " + propertyNode.Property.Name + " not found in source");
}
LambdaExpression lambda = Expression.Lambda(keySelector, parameterExpression);
MethodInfo orderByMethodInfo = GetOrderByMethodInfo(source, orderByClause.Direction, parameterExpression.Type, keySelector.Type);
source = Expression.Call(orderByMethodInfo, source, lambda);
orderByClause = orderByClause.ThenBy;
}
return(source);
}
public static Expression Build(OeJoinBuilder joinBuilder, Expression source, ParameterExpression parameterExpression, OrderByClause orderByClause)
{
while (orderByClause != null)
{
MemberExpression propertyExpression = GetPropertyExpression(joinBuilder, source, parameterExpression, orderByClause.Expression);
LambdaExpression lambda = Expression.Lambda(propertyExpression, parameterExpression);
MethodInfo orderByMethodInfo = GetOrderByMethodInfo(source, orderByClause.Direction, parameterExpression.Type, propertyExpression.Type);
source = Expression.Call(orderByMethodInfo, source, lambda);
orderByClause = orderByClause.ThenBy;
}
return(source);
}
protected void ResolveOrderByClause(OrderByClause orderBy, QuerySpecification firstqs)
{
if (orderBy != null)
{
ResolveTableReferences(firstqs, orderBy);
ResolveColumnReferences(firstqs, orderBy, ColumnContext.OrderBy);
}
}
public override void Visit(OrderByClause node) { this.action(node); }
public void AddOrderBy(OrderByClause orderBy)
{
OrderBy.Add(orderBy);
}
public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index) => ordering.TransformExpressions(_parentVisitor.Visit);
protected string ToOrderByDirective(OrderByClause item)
{
string name;
if (!string.IsNullOrWhiteSpace(item.Reference.GetOwner().GetAlias()))
{
name = string.Format("{0}.{1}", _schema.QuoteObjectName(item.Reference.GetOwner().GetAlias()),
_schema.QuoteObjectName(item.Reference.GetName()));
}
else if (_columns.Any(r => (!string.IsNullOrWhiteSpace(r.GetAlias())) && r.GetAlias().Equals(item.Reference.GetName())))
{
name = item.Reference.GetName();
}
else
{
var table = _schema.FindTable(item.Reference.GetOwner().GetName());
name = table.FindColumn(item.Reference.GetName()).QualifiedName;
}
var direction = item.Direction == OrderByDirection.Descending ? " DESC" : string.Empty;
return name + direction;
}
/// <summary>
/// Validates an <see cref="OrderByQueryOption" />.
/// </summary>
/// <param name="orderByOption">The $orderby query.</param>
/// <param name="validationSettings">The validation settings.</param>
public virtual void Validate(OrderByQueryOption orderByOption, ODataValidationSettings validationSettings)
{
if (orderByOption == null)
{
throw Error.ArgumentNull("orderByOption");
}
if (validationSettings == null)
{
throw Error.ArgumentNull("validationSettings");
}
int nodeCount = 0;
for (OrderByClause clause = orderByOption.OrderByClause; clause != null; clause = clause.ThenBy)
{
nodeCount++;
if (nodeCount > validationSettings.MaxOrderByNodeCount)
{
throw new ODataException(Error.Format(SRResources.OrderByNodeCountExceeded,
validationSettings.MaxOrderByNodeCount));
}
}
OrderByModelLimitationsValidator validator = new OrderByModelLimitationsValidator(orderByOption.Context.Model);
bool explicitAllowedProperties = validationSettings.AllowedOrderByProperties.Count > 0;
foreach (OrderByNode node in orderByOption.OrderByNodes)
{
string propertyName = null;
OrderByPropertyNode propertyNode = node as OrderByPropertyNode;
if (propertyNode != null)
{
propertyName = propertyNode.Property.Name;
bool isValidPath = !validator.TryValidate(propertyNode.OrderByClause, explicitAllowedProperties);
if (propertyName != null && isValidPath && explicitAllowedProperties)
{
// Explicit allowed properties were specified, but this one isn't within the list of allowed
// properties.
if (!IsAllowed(validationSettings, propertyName))
{
throw new ODataException(Error.Format(SRResources.NotAllowedOrderByProperty, propertyName,
"AllowedOrderByProperties"));
}
}
else if (propertyName != null)
{
// The property wasn't limited but it wasn't contained in the set of explicitly allowed
// properties.
if (!IsAllowed(validationSettings, propertyName))
{
throw new ODataException(Error.Format(SRResources.NotAllowedOrderByProperty, propertyName,
"AllowedOrderByProperties"));
}
}
}
else
{
propertyName = "$it";
if (!IsAllowed(validationSettings, propertyName))
{
throw new ODataException(Error.Format(SRResources.NotAllowedOrderByProperty, propertyName,
"AllowedOrderByProperties"));
}
}
}
}
private static void LiftOrderBy(
IQuerySource querySource,
Expression targetExpression,
QueryModel fromQueryModel,
QueryModel toQueryModel,
List <Expression> subQueryProjection)
{
var canRemove
= !fromQueryModel.ResultOperators
.Any(r => r is SkipResultOperator || r is TakeResultOperator);
foreach (var orderByClause
in fromQueryModel.BodyClauses.OfType <OrderByClause>().ToArray())
{
var outerOrderByClause = new OrderByClause();
foreach (var ordering in orderByClause.Orderings)
{
int projectionIndex;
var orderingExpression = ordering.Expression;
if (ordering.Expression.RemoveConvert() is NullConditionalExpression nullConditionalExpression)
{
orderingExpression = nullConditionalExpression.AccessOperation;
}
QuerySourceReferenceExpression orderingExpressionQsre = null;
string orderingExpressionName = null;
if (orderingExpression.RemoveConvert() is MemberExpression memberExpression &&
memberExpression.Expression.RemoveConvert() is QuerySourceReferenceExpression memberQsre &&
memberQsre.ReferencedQuerySource == querySource)
{
orderingExpressionQsre = memberQsre;
orderingExpressionName = memberExpression.Member.Name;
}
if (orderingExpression.RemoveConvert() is MethodCallExpression methodCallExpression &&
methodCallExpression.IsEFProperty() &&
methodCallExpression.Arguments[0].RemoveConvert() is QuerySourceReferenceExpression methodCallQsre &&
methodCallQsre.ReferencedQuerySource == querySource)
{
orderingExpressionQsre = methodCallQsre;
orderingExpressionName = (string)((ConstantExpression)methodCallExpression.Arguments[1]).Value;
}
if (orderingExpressionQsre != null &&
orderingExpressionName != null)
{
projectionIndex
= subQueryProjection
.FindIndex(
e =>
{
var expressionWithoutConvert = e.RemoveConvert();
var projectionExpression = (expressionWithoutConvert as NullConditionalExpression)?.AccessOperation
?? expressionWithoutConvert;
if (projectionExpression is MethodCallExpression methodCall &&
methodCall.Method.IsEFPropertyMethod())
{
var properyQsre = (QuerySourceReferenceExpression)methodCall.Arguments[0].RemoveConvert();
var propertyName = (string)((ConstantExpression)methodCall.Arguments[1]).Value;
return(properyQsre.ReferencedQuerySource == orderingExpressionQsre.ReferencedQuerySource &&
propertyName == orderingExpressionName);
}
if (projectionExpression is MemberExpression projectionMemberExpression)
{
var projectionMemberQsre = (QuerySourceReferenceExpression)projectionMemberExpression.Expression.RemoveConvert();
return(projectionMemberQsre.ReferencedQuerySource == orderingExpressionQsre.ReferencedQuerySource &&
projectionMemberExpression.Member.Name == orderingExpressionName);
}
return(false);
});
}
else
{
projectionIndex
= subQueryProjection
// Do NOT use orderingExpression variable here
.FindIndex(e => ExpressionEqualityComparer.Instance.Equals(e.RemoveConvert(), ordering.Expression.RemoveConvert()));
}
if (projectionIndex == -1)
{
projectionIndex = subQueryProjection.Count;
subQueryProjection.Add(
Expression.Convert(
// Workaround re-linq#RMLNQ-111 - When this is fixed the Clone can go away
CloningExpressionVisitor.AdjustExpressionAfterCloning(
ordering.Expression,
new QuerySourceMapping()),
typeof(object)));
}
var newExpression
= Expression.Call(
targetExpression,
AnonymousObject.GetValueMethodInfo,
Expression.Constant(projectionIndex));
outerOrderByClause.Orderings
.Add(new Ordering(newExpression, ordering.OrderingDirection));
}
toQueryModel.BodyClauses.Add(outerOrderByClause);
if (canRemove)
{
fromQueryModel.BodyClauses.Remove(orderByClause);
}
}
}
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index) => orderByClause.TransformExpressions(TransformingVisitor.Visit);
public void TestOrderBy_10()
{
_clause = new OrderByClause(new SqlServerDialect(), new TestEntityResolver(), new TestEntityAliasRegister());
_clause.OrderBy <Sample>(t => t.Email, true);
Assert.Equal("Order By [as_Sample].[t_Email] Desc", GetSql());
}
private static OeSkipTokenNameValue[] ParseSkipToken(IEdmModel edmModel, OrderByClause uniqueOrderBy, String skipToken)
{
return(ParseJson(edmModel, skipToken, GetEdmProperies(uniqueOrderBy)));
}
/// <summary>
/// 测试初始化
/// </summary>
public OrderByClauseTest()
{
_clause = new OrderByClause(new SqlServerDialect(), new EntityResolver(), new EntityAliasRegister());
}
/// <summary>
/// Adds the order by.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="order">The order.</param>
public void AddOrderBy(string field, Sorting order)
{
var newOrderByClause = new OrderByClause(field, order);
OrderByStatement.Add(newOrderByClause);
}
public Expression ApplySkipToken(Expression source, OeSkipTokenNameValue[] skipTokenNameValues, OrderByClause uniqueOrderBy, bool isDatabaseNullHighestValue)
{
if (skipTokenNameValues == null || skipTokenNameValues.Length == 0)
{
return(source);
}
var skipTokenTranslator = new Translators.OeSkipTokenTranslator(Visitor, _joinBuilder, isDatabaseNullHighestValue);
source = skipTokenTranslator.Build(source, skipTokenNameValues, uniqueOrderBy);
Visitor.ChangeParameterType(source);
return(source);
}
/// <summary>
/// Adds the order by.
/// </summary>
/// <param name="clause">The clause.</param>
public void AddOrderBy(OrderByClause clause)
{
OrderByStatement.Add(clause);
}
/// <summary>
/// Visits the order by clause.
/// </summary>
/// <param name="orderByClause">The order by clause.</param>
/// <param name="queryModel">The query model.</param>
/// <param name="index">The index.</param>
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
this.VisitOrderings(orderByClause.Orderings, queryModel, orderByClause);
}
public ODataSortingParser(OrderByClause x)
{
node = x;
}
/// <summary>Selects rows in the hierarchy under the current entity.</summary>
/// <param name="conn">Connection-transcation context to use.</param>
/// <param name="rootEntity">Root entity.</param>
/// <param name="recursiveRelation">Recursive relation which defines a hierarchy.</param>
/// <param name="leafFilter">The search condition which restricts the rows returned. Often a criteria which filters out deactivated records.</param>
/// <param name="sorter">Order by.</param>
/// <param name="sortOnDb">Specifies whether sorting will take place on database or in DataTable after data has been fetched.</param>
/// <param name="beginAtLevel">Zero-based index of the first level to fetch. Zero indicates that fetching starts at current entity,
/// one indicates that fetching starts at the level directly beneath it etc.</param>
/// <param name="endAtLevel">Zero-based index of the last level to fetch. Zero indicates that fetching ends at current entity,
/// one indicates that fetching ends at the level directly beneath it etc. <see cref="System.Int32.MaxValue"/> indicates that operation ends at leaf nodes.</param>
/// <returns>Rows in the hierarchy under the current entity.</returns>
public DataTable SelectTree(IConnectionProvider conn, IEntity rootEntity, DbRelation recursiveRelation, SearchCondition leafFilter, OrderByClause sorter, bool sortOnDb, int beginAtLevel, int endAtLevel)
{
EnsureRecursiveRelation(recursiveRelation);
EnsureValidBeginAndEndLevels(beginAtLevel, endAtLevel);
DataTable mergedData;
if (SearchCondition.IsNullOrEmpty(leafFilter))
mergedData = SelectAll(conn, rootEntity, recursiveRelation, beginAtLevel, endAtLevel);
else
mergedData = SelectWithLeafFilter(conn, rootEntity, recursiveRelation, leafFilter, beginAtLevel, endAtLevel);
if (mergedData == null)
mergedData = rootEntity.Table.NewDataTable();
if (mergedData.Rows.Count > 0)
mergedData = SortDataTable(mergedData, sorter);
return mergedData;
}
private string ToOrderByDirective(OrderByClause item)
{
string name;
if (_columns.Any(r => (!string.IsNullOrWhiteSpace(r.GetAlias())) && r.GetAlias().Equals(item.Reference.GetName())))
{
name = item.Reference.GetName();
}
else
{
name = _table.FindColumn(item.Reference.GetName()).QualifiedName;
}
var direction = item.Direction == OrderByDirection.Descending ? " DESC" : string.Empty;
return name + direction;
}
public void Init()
{
instance = new OrderByClause();
}
private string ToOrderByDirective(OrderByClause item)
{
var col = _table.FindColumn(item.Reference.GetName());
var direction = item.Direction == OrderByDirection.Descending ? " DESC" : string.Empty;
return col.QualifiedName + direction;
}
public DataTable SelectTree(IConnectionProvider conn, IEntity rootEntity, DbRelation recursiveRelation, SearchCondition leafFilter, OrderByClause sorter, bool sortOnDb, int beginAtLevel, int endAtLevel)
{
EnsureRecursiveRelation(recursiveRelation);
EnsureValidBeginAndEndLevels(beginAtLevel, endAtLevel);
// select target.* from target where exists ... and ...
RecursiveStatement cte = new RecursiveStatement(rootEntity, recursiveRelation);
cte.Select = new SelectStatement(rootEntity.Table, rootEntity.Table.Columns);
cte.Select.Where = CreateWhere(rootEntity, cte, leafFilter, beginAtLevel, endAtLevel);
if (sortOnDb && !OrderByClause.IsNullOrEmpty(sorter))
cte.Select.OrderBy = sorter;
DataTable data = cte.ExecuteSelect(conn);
if (!sortOnDb && !OrderByClause.IsNullOrEmpty(sorter))
data = GenericHierarchicalQueryExecutor.SortDataTable(data, sorter);
return data;
}
internal override string ToString(string indent)
{
var sb = new StringBuilder(1024);
sb.AppendFormat("{0}SELECT ", indent);
if (TopRowFilter != null)
{
if (TopRowFilter.OneLine())
{
sb.AppendFormat("{0} ", TopRowFilter.ToString(""));
}
else
{
sb.Append("\r\n");
sb.AppendFormat("{0} ", TopRowFilter.ToString(indent));
}
}
switch (UniqueRowFilter)
{
case UniqueRowFilter.All:
sb.Append("ALL ");
break;
case UniqueRowFilter.Distinct:
sb.Append("DISTINCT ");
break;
}
for (var i = 0; i < SelectElements.Count; i++)
{
if (i > 0)
{
sb.Append(", ");
}
if (SelectElements[i].OneLine())
{
sb.Append(SelectElements[i].ToString(""));
}
else
{
sb.Append("\r\n");
sb.Append(SelectElements[i].ToString(indent + " "));
}
}
if (Into != null)
{
sb.AppendFormat(" INTO {0} ", Into);
}
if (FromClause.TableReferences != null)
{
sb.Append("\r\n");
sb.Append(FromClause.ToString(indent));
}
if (WhereClause.SearchCondition != null || !string.IsNullOrEmpty(WhereClause.GhostString))
{
sb.Append("\r\n");
sb.Append(WhereClause.ToString(indent));
}
if (GroupByClause != null)
{
sb.Append("\r\n");
sb.Append(GroupByClause.ToString(indent));
}
if (HavingClause != null)
{
sb.Append("\r\n");
sb.Append(HavingClause.ToString(indent));
}
if (OrderByClause != null)
{
sb.Append("\r\n");
sb.Append(OrderByClause.ToString(indent));
}
return(sb.ToString());
}
private static string BuildOrderByClauseString(OrderByClause clause)
{
return(clause.SortOrder == SortingOperator.Descending
? $"{WrapVariable(clause.ColumnName)} DESC"
: $"{WrapVariable(clause.ColumnName)}");
}
public static Dictionary<string, OrderByInfo> OrderByInfos(QuerySpecification querySpecification, OrderByClause orderByClause)
{
var orderByInfos = new Dictionary<string, OrderByInfo>();
if (orderByClause != null)
{
foreach (var expressionWithSortOrder in orderByClause.OrderByElements)
{
var tableName = TableFromFullyQualifiedColumnName(ExpressionPartName(expressionWithSortOrder.Expression),querySpecification);
var columnName = ColumnFromFullyQualifiedColumnName(ExpressionPartName(expressionWithSortOrder.Expression));
var descending = expressionWithSortOrder.SortOrder == SortOrder.Descending;
orderByInfos.Add(tableName + "." + columnName, new OrderByInfo
{
TableName = tableName,
ColumnName = columnName,
Descending = descending
});
}
}
return orderByInfos;
}
private IQueryElement ConvertInternal(IQueryElement element, Func <IQueryElement, IQueryElement> action)
{
if (element == null)
{
return(null);
}
IQueryElement newElement;
if (_visitedElements.TryGetValue(element, out newElement))
{
return(newElement);
}
switch (element.ElementType)
{
case EQueryElementType.SqlFunction:
{
var func = (ISqlFunction)element;
var parms = Convert(func.Parameters, action);
if (parms != null && !ReferenceEquals(parms, func.Parameters))
{
newElement = new SqlFunction(func.SystemType, func.Name, func.Precedence, parms);
}
break;
}
case EQueryElementType.SqlExpression:
{
var expr = (ISqlExpression)element;
var parameter = Convert(expr.Parameters, action);
if (parameter != null && !ReferenceEquals(parameter, expr.Parameters))
{
newElement = new SqlExpression(expr.SystemType, expr.Expr, expr.Precedence, parameter);
}
break;
}
case EQueryElementType.SqlBinaryExpression:
{
var bexpr = (ISqlBinaryExpression)element;
var expr1 = (IQueryExpression)ConvertInternal(bexpr.Expr1, action);
var expr2 = (IQueryExpression)ConvertInternal(bexpr.Expr2, action);
if (expr1 != null && !ReferenceEquals(expr1, bexpr.Expr1) ||
expr2 != null && !ReferenceEquals(expr2, bexpr.Expr2))
{
newElement = new SqlBinaryExpression(bexpr.SystemType, expr1 ?? bexpr.Expr1, bexpr.Operation,
expr2 ?? bexpr.Expr2, bexpr.Precedence);
}
break;
}
case EQueryElementType.SqlTable:
{
var table = (ISqlTable)element;
var fields1 = ToArray(table.Fields);
var fields2 = Convert(fields1, action, f => new SqlField(f));
var targs = table.TableArguments == null
? null
: Convert(table.TableArguments, action);
var fe = fields2 == null || ReferenceEquals(fields1, fields2);
var ta = ReferenceEquals(table.TableArguments, targs);
if (!fe || !ta)
{
if (fe)
{
fields2 = fields1;
for (var i = 0; i < fields2.Length; i++)
{
var field = fields2[i];
fields2[i] = new SqlField(field);
_visitedElements[field] = fields2[i];
}
}
newElement = new SqlTable(table, fields2, targs ?? table.TableArguments);
}
break;
}
case EQueryElementType.Column:
{
var col = (IColumn)element;
var expr = (IQueryExpression)ConvertInternal(col.Expression, action);
IQueryElement parent;
_visitedElements.TryGetValue(col.Parent, out parent);
if (parent != null || expr != null && !ReferenceEquals(expr, col.Expression))
{
newElement = new Column(parent == null
? col.Parent
: (ISelectQuery)parent, expr ?? col.Expression, col.Alias);
}
break;
}
case EQueryElementType.TableSource:
{
var table = (ITableSource)element;
var source = (ISqlTableSource)ConvertInternal(table.Source, action);
var joins = Convert(table.Joins, action);
if (source != null && !ReferenceEquals(source, table.Source) ||
joins != null && !ReferenceEquals(table.Joins, joins))
{
newElement = new TableSource(source ?? table.Source, table.Alias, joins ?? table.Joins);
}
break;
}
case EQueryElementType.JoinedTable:
{
var join = (IJoinedTable)element;
var table = (ITableSource)ConvertInternal(join.Table, action);
var cond = (ISearchCondition)ConvertInternal(join.Condition, action);
if (table != null && !ReferenceEquals(table, join.Table) ||
cond != null && !ReferenceEquals(cond, join.Condition))
{
newElement = new JoinedTable(join.JoinType, table ?? join.Table, join.IsWeak,
cond ?? join.Condition);
}
break;
}
case EQueryElementType.SearchCondition:
{
var sc = (ISearchCondition)element;
var conds = Convert(sc.Conditions, action);
if (conds != null && !ReferenceEquals(sc.Conditions, conds))
{
newElement = new SearchCondition(conds);
}
break;
}
case EQueryElementType.Condition:
{
var c = (Condition)element;
var p = (ISqlPredicate)ConvertInternal(c.Predicate, action);
if (p != null && !ReferenceEquals(c.Predicate, p))
{
newElement = new Condition(c.IsNot, p, c.IsOr);
}
break;
}
case EQueryElementType.ExprPredicate:
{
var p = (IExpr)element;
var e = (IQueryExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new Expr(e, p.Precedence);
}
break;
}
case EQueryElementType.NotExprPredicate:
{
var p = (INotExpr)element;
var e = (IQueryExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new NotExpr(e, p.IsNot, p.Precedence);
}
break;
}
case EQueryElementType.ExprExprPredicate:
{
var p = (IExprExpr)element;
var e1 = (IQueryExpression)ConvertInternal(p.Expr1, action);
var e2 = (IQueryExpression)ConvertInternal(p.Expr2, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) || e2 != null && !ReferenceEquals(p.Expr2, e2))
{
newElement = new ExprExpr(e1 ?? p.Expr1, p.EOperator, e2 ?? p.Expr2);
}
break;
}
case EQueryElementType.LikePredicate:
{
var p = (ILike)element;
var e1 = (IQueryExpression)ConvertInternal(p.Expr1, action);
var e2 = (IQueryExpression)ConvertInternal(p.Expr2, action);
var es = (IQueryExpression)ConvertInternal(p.Escape, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) || e2 != null && !ReferenceEquals(p.Expr2, e2) ||
es != null && !ReferenceEquals(p.Escape, es))
{
newElement = new Like(e1 ?? p.Expr1, p.IsNot, e2 ?? p.Expr2, es ?? p.Escape);
}
break;
}
case EQueryElementType.HierarhicalPredicate:
{
var p = (IHierarhicalPredicate)element;
var e1 = (IQueryExpression)ConvertInternal(p.Expr1, action);
var e2 = (IQueryExpression)ConvertInternal(p.Expr2, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) || e2 != null && !ReferenceEquals(p.Expr2, e2))
{
newElement = new HierarhicalPredicate(e1 ?? p.Expr1, e2 ?? p.Expr2, p.Flow);
}
break;
}
case EQueryElementType.BetweenPredicate:
{
var p = (IBetween)element;
var e1 = (IQueryExpression)ConvertInternal(p.Expr1, action);
var e2 = (IQueryExpression)ConvertInternal(p.Expr2, action);
var e3 = (IQueryExpression)ConvertInternal(p.Expr3, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) || e2 != null && !ReferenceEquals(p.Expr2, e2) ||
e3 != null && !ReferenceEquals(p.Expr3, e3))
{
newElement = new Between(e1 ?? p.Expr1, p.IsNot, e2 ?? p.Expr2, e3 ?? p.Expr3);
}
break;
}
case EQueryElementType.IsNullPredicate:
{
var p = (IIsNull)element;
var e = (IQueryExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new IsNull(e, p.IsNot);
}
break;
}
case EQueryElementType.InSubQueryPredicate:
{
var p = (IInSubQuery)element;
var e = (IQueryExpression)ConvertInternal(p.Expr1, action);
var q = (ISelectQuery)ConvertInternal(p.SubQuery, action);
if (e != null && !ReferenceEquals(p.Expr1, e) || q != null && !ReferenceEquals(p.SubQuery, q))
{
newElement = new InSubQuery(e ?? p.Expr1, p.IsNot, q ?? p.SubQuery);
}
break;
}
case EQueryElementType.InListPredicate:
{
var p = (IInList)element;
var e = (IQueryExpression)ConvertInternal(p.Expr1, action);
var v = Convert(p.Values, action);
if (e != null && !ReferenceEquals(p.Expr1, e) || v != null && !ReferenceEquals(p.Values, v))
{
newElement = new InList(e ?? p.Expr1, p.IsNot, v ?? p.Values);
}
break;
}
case EQueryElementType.FuncLikePredicate:
{
var p = (IFuncLike)element;
var f = (ISqlFunction)ConvertInternal(p.Function, action);
if (f != null && !ReferenceEquals(p.Function, f))
{
newElement = new FuncLike(f);
}
break;
}
case EQueryElementType.SetExpression:
{
var s = (ISetExpression)element;
var c = (IQueryExpression)ConvertInternal(s.Column, action);
var e = (IQueryExpression)ConvertInternal(s.Expression, action);
if (c != null && !ReferenceEquals(s.Column, c) || e != null && !ReferenceEquals(s.Expression, e))
{
newElement = new SetExpression(c ?? s.Column, e ?? s.Expression);
}
break;
}
case EQueryElementType.InsertClause:
{
var s = (IInsertClause)element;
var t = s.Into != null
? (ISqlTable)ConvertInternal(s.Into, action)
: null;
var i = Convert(s.Items, action);
if (t != null && !ReferenceEquals(s.Into, t) || i != null && !ReferenceEquals(s.Items, i))
{
var sc = new InsertClause
{
Into = t ?? s.Into
};
(i ?? s.Items).ForEach(node => sc.Items.AddLast(node.Value));
sc.WithIdentity = s.WithIdentity;
newElement = sc;
}
break;
}
case EQueryElementType.UpdateClause:
{
var s = (IUpdateClause)element;
var t = s.Table != null
? (ISqlTable)ConvertInternal(s.Table, action)
: null;
var i = Convert(s.Items, action);
var k = Convert(s.Keys, action);
if (t != null && !ReferenceEquals(s.Table, t) || i != null && !ReferenceEquals(s.Items, i) ||
k != null && !ReferenceEquals(s.Keys, k))
{
var sc = new UpdateClause
{
Table = t ?? s.Table
};
(i ?? s.Items).ForEach(node => sc.Items.AddLast(node.Value));
(k ?? s.Keys).ForEach(node => sc.Keys.AddLast(node.Value));
newElement = sc;
}
break;
}
case EQueryElementType.DeleteClause:
{
var s = (IDeleteClause)element;
var t = s.Table != null
? (ISqlTable)ConvertInternal(s.Table, action)
: null;
if (t != null && !ReferenceEquals(s.Table, t))
{
newElement = new DeleteClause
{
Table = t
};
}
break;
}
case EQueryElementType.CreateTableStatement:
{
var s = (ICreateTableStatement)element;
var t = s.Table != null
? (ISqlTable)ConvertInternal(s.Table, action)
: null;
if (t != null && !ReferenceEquals(s.Table, t))
{
newElement = new CreateTableStatement
{
Table = t,
IsDrop = s.IsDrop
};
}
break;
}
case EQueryElementType.SelectClause:
{
var sc = (ISelectClause)element;
var cols = Convert(sc.Columns, action);
var take = (IQueryExpression)ConvertInternal(sc.TakeValue, action);
var skip = (IQueryExpression)ConvertInternal(sc.SkipValue, action);
IQueryElement parent;
_visitedElements.TryGetValue(sc.SelectQuery, out parent);
if (parent != null || cols != null && !ReferenceEquals(sc.Columns, cols) ||
take != null && !ReferenceEquals(sc.TakeValue, take) ||
skip != null && !ReferenceEquals(sc.SkipValue, skip))
{
newElement = new SelectClause(sc.IsDistinct, take ?? sc.TakeValue, skip ?? sc.SkipValue,
cols ?? sc.Columns);
((ISelectClause)newElement).SetSqlQuery((ISelectQuery)parent);
}
break;
}
case EQueryElementType.FromClause:
{
var fc = (IFromClause)element;
var ts = Convert(fc.Tables, action);
IQueryElement parent;
_visitedElements.TryGetValue(fc.SelectQuery, out parent);
if (parent != null || ts != null && !ReferenceEquals(fc.Tables, ts))
{
newElement = new FromClause(ts ?? fc.Tables);
((IFromClause)newElement).SetSqlQuery((ISelectQuery)parent);
}
break;
}
case EQueryElementType.WhereClause:
{
var wc = (IWhereClause)element;
var cond = (ISearchCondition)ConvertInternal(wc.Search, action);
IQueryElement parent;
_visitedElements.TryGetValue(wc.SelectQuery, out parent);
if (parent != null || cond != null && !ReferenceEquals(wc.Search, cond))
{
newElement = new WhereClause(cond ?? wc.Search);
((IWhereClause)newElement).SetSqlQuery((ISelectQuery)parent);
}
break;
}
case EQueryElementType.GroupByClause:
{
var gc = (IGroupByClause)element;
var es = Convert(gc.Items, action);
IQueryElement parent;
_visitedElements.TryGetValue(gc.SelectQuery, out parent);
if (parent != null || es != null && !ReferenceEquals(gc.Items, es))
{
newElement = new GroupByClause(es ?? gc.Items);
((IGroupByClause)newElement).SetSqlQuery((ISelectQuery)parent);
}
break;
}
case EQueryElementType.OrderByClause:
{
var oc = (IOrderByClause)element;
var es = Convert(oc.Items, action);
IQueryElement parent;
_visitedElements.TryGetValue(oc.SelectQuery, out parent);
if (parent != null || es != null && !ReferenceEquals(oc.Items, es))
{
newElement = new OrderByClause(es ?? oc.Items);
((IOrderByClause)newElement).SetSqlQuery((ISelectQuery)parent);
}
break;
}
case EQueryElementType.OrderByItem:
{
var i = (IOrderByItem)element;
var e = (IQueryExpression)ConvertInternal(i.Expression, action);
if (e != null && !ReferenceEquals(i.Expression, e))
{
newElement = new OrderByItem(e, i.IsDescending);
}
break;
}
case EQueryElementType.Union:
{
var u = (IUnion)element;
var q = (ISelectQuery)ConvertInternal(u.SelectQuery, action);
if (q != null && !ReferenceEquals(u.SelectQuery, q))
{
newElement = new Union(q, u.IsAll);
}
break;
}
case EQueryElementType.SqlQuery:
{
var q = (ISelectQuery)element;
IQueryElement parent = null;
var doConvert = false;
if (q.ParentSelect != null)
{
if (!_visitedElements.TryGetValue(q.ParentSelect, out parent))
{
doConvert = true;
parent = q.ParentSelect;
}
}
if (!doConvert)
{
doConvert = null != FindFirstOrDefault <IQueryElement>(q, e =>
{
if (_visitedElements.ContainsKey(e) && _visitedElements[e] != e)
{
return(true);
}
var ret = action(e);
if (ret != null && !ReferenceEquals(e, ret))
{
_visitedElements.Add(e, ret);
return(true);
}
return(false);
});
}
if (!doConvert)
{
break;
}
var nq = new SelectQuery
{
EQueryType = q.EQueryType
};
_visitedElements.Add(q, nq);
var fc = (IFromClause)ConvertInternal(q.From, action) ?? q.From;
var sc = (ISelectClause)ConvertInternal(q.Select, action) ?? q.Select;
var ic = q.IsInsert
? ((IInsertClause)ConvertInternal(q.Insert, action) ?? q.Insert)
: null;
var uc = q.IsUpdate
? ((IUpdateClause)ConvertInternal(q.Update, action) ?? q.Update)
: null;
var dc = q.IsDelete
? ((IDeleteClause)ConvertInternal(q.Delete, action) ?? q.Delete)
: null;
var wc = (IWhereClause)ConvertInternal(q.Where, action) ?? q.Where;
var gc = (IGroupByClause)ConvertInternal(q.GroupBy, action) ?? q.GroupBy;
var hc = (IWhereClause)ConvertInternal(q.Having, action) ?? q.Having;
var oc = (IOrderByClause)ConvertInternal(q.OrderBy, action) ?? q.OrderBy;
var us = q.HasUnion
? Convert(q.Unions, action)
: q.Unions;
var ps = new List <ISqlParameter>(q.Parameters.Count);
foreach (var p in q.Parameters)
{
IQueryElement e;
if (_visitedElements.TryGetValue(p, out e))
{
if (e == null)
{
ps.Add(p);
}
else
{
var sqlParameter = e as ISqlParameter;
if (sqlParameter != null)
{
ps.Add(sqlParameter);
}
}
}
}
nq.Init(ic, uc, dc, sc, fc, wc, gc, hc, oc, us, (ISelectQuery)parent, q.CreateTable,
q.IsParameterDependent, ps);
_visitedElements[q] = action(nq) ?? nq;
return(nq);
}
}
newElement = newElement == null
? action(element)
: (action(newElement) ?? newElement);
_visitedElements.Add(element, newElement);
return(newElement);
}
/// <summary>
/// Visits the ordering.
/// </summary>
/// <param name="ordering">The ordering.</param>
/// <param name="queryModel">The query model.</param>
/// <param name="orderByClause">The order by clause.</param>
/// <param name="index">The index.</param>
public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
{
var memberMapPath = MemberMapPathBuilder.BuildFrom(this.mongoSession.MappingStore, ordering.Expression);
this.querySpec.OrderBy[memberMapPath.Key] = ordering.OrderingDirection == OrderingDirection.Asc ? 1 : -1;
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
QueryParts.AddOrderBy(orderByClause);
base.VisitOrderByClause(orderByClause, queryModel, index);
}
internal static DataTable SortDataTable(DataTable unsortedData, OrderByClause orderBy)
{
bool shouldSort = (orderBy != null && orderBy.Count > 0);
if (!shouldSort)
return unsortedData;
DataRow[] sortedRows = unsortedData.Select(null, orderBy.GetDataViewSortExpression());
DataTable sortedData = unsortedData.Clone();
sortedData.BeginLoadData();
foreach (DataRow row in sortedRows)
sortedData.ImportRow(row);
sortedData.EndLoadData();
return sortedData;
}
public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
{
ordering.TransformExpressions(e => MergeAggregatingResultsInExpressionRewriter.Rewrite(e, new NameGenerator(queryModel)));
}
/// <summary>
/// 初始化
/// </summary>
public virtual void Init()
{
OrderByClause.OrderBy(Pager?.Order);
}
/// <summary>
/// 验证
/// </summary>
public virtual void Validate()
{
FromClause.Validate();
OrderByClause.Validate(IsLimit);
}
private WOrderByClause ParseOrderbyClause(OrderByClause orderbyExpr)
{
var wobc = new WOrderByClause
{
FirstTokenIndex = orderbyExpr.FirstTokenIndex,
LastTokenIndex = orderbyExpr.LastTokenIndex,
OrderByElements = new List<WExpressionWithSortOrder>(orderbyExpr.OrderByElements.Count)
};
foreach (var pexp in from e in orderbyExpr.OrderByElements
let pscalar = ParseScalarExpression(e.Expression)
where pscalar != null
select new WExpressionWithSortOrder
{
ScalarExpr = pscalar,
SortOrder = e.SortOrder,
FirstTokenIndex = e.FirstTokenIndex,
LastTokenIndex = e.LastTokenIndex
})
{
wobc.OrderByElements.Add(pexp);
}
return wobc;
}
public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
{
_orderByClause = _hqlTreeBuilder.OrderBy();
foreach (Ordering clause in orderByClause.Orderings)
{
var visitor = new HqlGeneratorExpressionTreeVisitor(_parameterAggregator);
visitor.Visit(clause.Expression);
_orderByClause.AddChild(visitor.GetHqlTreeNodes().Single());
_orderByClause.AddChild(clause.OrderingDirection == OrderingDirection.Asc
? _hqlTreeBuilder.Ascending()
: (HqlTreeNode) _hqlTreeBuilder.Descending());
}
base.VisitOrderByClause(orderByClause, queryModel, index);
}
