/// <summary>
/// Convert this ordering node into an OData string representation.
/// </summary>
/// <returns>The OData string</returns>
public static string ToODataString(this OrderByNode node)
{
string field = ODataExpressionVisitor.ToODataString(node.Expression);
string direction = node.Direction == OrderByDirection.Ascending ? "" : " desc";
return($"{field}{direction}");
}
public void Visit(OrderByNode node)
{
node.Inner[0].Accept(this);
OrderedParallelQuery <LogItem> ordered;
if (node.Descending[0])
{
ordered = Items.OrderByDescending(i => i.Fields[node.Fields[0]]);
}
else
{
ordered = Items.OrderBy(i => i.Fields[node.Fields[0]]);
}
for (var n = 1; n < node.Fields.Length; n++)
{
if (node.Descending[n])
{
ordered = ordered.ThenByDescending(i => i.Fields[node.Fields[n]]);
}
else
{
ordered = ordered.ThenBy(i => i.Fields[node.Fields[n]]);
}
}
Items = ordered;
}
public void Visit(OrderByNode node)
{
foreach (var inner in node.Inner)
{
inner.Accept(this);
}
}
public void CreateCollection_CopmplexType_Succeeds()
{
// Arrange
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
ODataQueryOptionParser parser = new ODataQueryOptionParser(model.Model, model.Customer, model.Customers,
new Dictionary <string, string> {
{ "$orderby", "Address/Street desc, Address/City asc, Account/BankAddress/City asc" }
});
OrderByClause orderByNode = parser.ParseOrderBy();
// Act
ICollection <OrderByNode> nodes = OrderByNode.CreateCollection(orderByNode);
// Assert
Assert.Equal(3, nodes.Count());
Assert.Equal("Street", (nodes.ToList()[0] as OrderByPropertyNode).Property.Name);
Assert.Equal(OrderByDirection.Descending, nodes.ToList()[0].Direction);
Assert.Equal("Address/Street", nodes.ToList()[0].PropertyPath);
Assert.Equal("City", (nodes.ToList()[1] as OrderByPropertyNode).Property.Name);
Assert.Equal(OrderByDirection.Ascending, nodes.ToList()[1].Direction);
Assert.Equal("Address/City", nodes.ToList()[1].PropertyPath);
Assert.Equal("City", (nodes.ToList()[2] as OrderByPropertyNode).Property.Name);
Assert.Equal(OrderByDirection.Ascending, nodes.ToList()[2].Direction);
Assert.Equal("Account/BankAddress/City", nodes.ToList()[2].PropertyPath);
}
public void Visit(OrderByNode node)
{
foreach (var field in node.Fields)
{
field.Accept(this);
}
node.Accept(_visitor);
}
public void Visit(OrderByNode node)
{
Expression sequence = _visitor.Nodes.Peek();
this._visitor.ScopedParamters.Push(Expression.Parameter(sequence.GetElementType(), "item_" + sequence.GetElementType().Name));
foreach (var field in node.Fields)
field.Accept(this);
node.Accept(_visitor);
}
public void Visit(OrderByNode node)
{
var fields = new FieldOrderedNode[node.Fields.Length];
for (var i = node.Fields.Length - 1; i >= 0; --i)
{
fields[i] = (FieldOrderedNode)Nodes.Pop();
}
Nodes.Push(new OrderByNode(fields));
}
/// <summary>
/// Add an ordering constraint for an OrderBy/ThenBy call.
/// </summary>
/// <param name="expression">
/// The ordering method call.
/// </param>
/// <param name="ascending">
/// Whether the order is ascending or descending.
/// </param>
/// <param name="prepend">
/// Indicates if the expression should be prepended or not.
/// </param>
private void AddOrdering(MethodCallExpression expression, bool ascending, bool prepend = false)
{
// Keep updating with the deepest nested expression structure we
// can get to so that we can provide a more detailed error message
Expression deepest = expression;
// We only allow OrderBy(x => x.Member) expressions. Anything else
// will result in a NotSupportedException.
if (expression != null && expression.Arguments.Count >= 2)
{
LambdaExpression lambda = StripQuote(expression.Arguments[1]) as LambdaExpression;
if (lambda != null)
{
deepest = lambda.Body ?? lambda;
// Find the name of the member being ordered
MemberExpression memberAccess = lambda.Body as MemberExpression;
if (memberAccess != null)
{
string memberName = FilterBuildingExpressionVisitor.GetTableMemberName(memberAccess);
if (memberName != null)
{
OrderByDirection direction = ascending ? OrderByDirection.Ascending : OrderByDirection.Descending;
var node = new OrderByNode(new MemberAccessNode(null, memberName), direction);
// Add the ordering
if (prepend)
{
this.queryDescription.Ordering.Insert(0, node);
}
else
{
this.queryDescription.Ordering.Add(node);
}
return;
}
}
}
}
throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
"'{0}' Mobile Services query expressions must consist of members only, not '{1}'.",
expression != null && expression.Method != null ? expression.Method.Name : null,
deepest != null ? deepest.ToString() : null));
}
public ODataHelperViewModel <T> GetOData(HttpContext context, ODataHelper <T> oData)
{
string queryString = string.Empty;
if (context != null &&
context.Request != null &&
context.Request.QueryString != null &&
context.Request.QueryString.HasValue)
{
queryString = context.Request.QueryString.Value;
}
oData.Parse(queryString);
Guid parentguid = Guid.Empty;
var newNode = oData.ParseOrderByQuery(queryString);
if (newNode == null)
{
newNode = new OrderByNode <T>();
}
Predicate <T> predicate = null;
if (oData != null && oData.Filter != null)
{
predicate = new Predicate <T>(oData.Filter);
}
int take = (oData?.Top == null || oData?.Top == 0) ? 100 : oData.Top;
ODataHelperViewModel <T> oDataHelperViewModel = new ODataHelperViewModel <T>()
{
Direction = newNode.Direction,
Predicate = predicate,
Skip = oData.Skip,
PropertyName = newNode.PropertyName,
Take = take,
Filter = oData.Filter,
Sort = oData.Sort,
Top = oData.Top,
SortDirection = oData.SortDirection
};
return(oDataHelperViewModel);
}
/// <summary>
/// Add an ordering expression to the query
/// </summary>
/// <param name="expression">An ordering method call expression</param>
/// <param name="ascending">True if the ordering is ascending, false otherwise</param>
/// <param name="prepend">True to prepend the ordering to the list</param>
internal protected void AddOrdering(MethodCallExpression expression, bool ascending, bool prepend)
{
// We only allow keySelectors that are x => x.member expressions (i.e. MemberAccessNode).
// Anything else will result in a NotSupportedException
if (expression.IsValidLambdaExpression(out LambdaExpression lambda) && lambda !.Body is MemberExpression memberExpression)
{
string memberName = FilterBuildingExpressionVisitor.GetTableMemberName(memberExpression, ContractResolver);
if (memberName != null)
{
var node = new OrderByNode(new MemberAccessNode(null, memberName), ascending);
if (prepend)
{
QueryDescription.Ordering.Insert(0, node);
}
else
{
QueryDescription.Ordering.Add(node);
}
}
}
public void CreateCollection_PropertyAliased_IfEnabled(bool modelAliasing, string typeName, string propertyName)
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ModelAliasingEnabled = modelAliasing;
builder.EntitySet <PropertyAlias>("entityset");
IEdmModel model = builder.GetEdmModel();
IEdmEntityType entityType = model.SchemaElements.Single(t => t.Name == typeName) as IEdmEntityType;
Assert.NotNull(entityType); // Guard
IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("entityset");
Assert.NotNull(entitySet); // Guard
ODataQueryOptionParser parser = new ODataQueryOptionParser(model, entityType, entitySet,
new Dictionary <string, string> {
{ "$orderby", propertyName + " desc, Id asc" }
});
OrderByClause orderbyNode = parser.ParseOrderBy();
// Act
ICollection <OrderByNode> nodes = OrderByNode.CreateCollection(orderbyNode);
// Assert
Assert.False(nodes.OfType <OrderByItNode>().Any());
IEnumerable <OrderByPropertyNode> propertyNodes = nodes.OfType <OrderByPropertyNode>();
Assert.Equal(2, propertyNodes.Count());
Assert.Equal(propertyName, propertyNodes.First().Property.Name);
Assert.Equal(OrderByDirection.Descending, propertyNodes.First().Direction);
Assert.Equal(propertyName, propertyNodes.First().PropertyPath);
Assert.Equal("Id", propertyNodes.Last().Property.Name);
Assert.Equal(OrderByDirection.Ascending, nodes.Last().Direction);
Assert.Equal("Id", propertyNodes.Last().PropertyPath);
}
public PaginatedList <ProcessExecutionViewModel> View(
[FromQuery(Name = "$filter")] string filter = "",
[FromQuery(Name = "$orderby")] string orderBy = "",
[FromQuery(Name = "$top")] int top = 100,
[FromQuery(Name = "$skip")] int skip = 0
)
{
ODataHelper <ProcessExecutionViewModel> oData = new ODataHelper <ProcessExecutionViewModel>();
string queryString = "";
if (HttpContext != null &&
HttpContext.Request != null &&
HttpContext.Request.QueryString != null &&
HttpContext.Request.QueryString.HasValue)
{
queryString = HttpContext.Request.QueryString.Value;
}
oData.Parse(queryString);
Guid parentguid = Guid.Empty;
var newNode = oData.ParseOrderByQuerry(queryString);
if (newNode == null)
{
newNode = new OrderByNode <ProcessExecutionViewModel>();
}
Predicate <ProcessExecutionViewModel> predicate = null;
if (oData != null && oData.Filter != null)
{
predicate = new Predicate <ProcessExecutionViewModel>(oData.Filter);
}
int take = (oData?.Top == null || oData?.Top == 0) ? 100 : oData.Top;
return(processExecutionLogManager.GetProcessAndAgentNames(predicate, newNode.PropertyName, newNode.Direction, oData.Skip, take));
}
public OrderByNode <T> ParseOrderByQuery(string queryString)
{
try
{
OrderByNode <T> response = null;
if (!string.IsNullOrEmpty(queryString))
{
var queryStrings = HttpUtility.ParseQueryString(queryString);
if (queryStrings.HasKeys() && queryStrings.AllKeys.Contains("$orderby"))
{
string orderby = queryStrings["$orderby"];
OrderByClause <T> orderbyClause = new OrderByClause <T>();
response = orderbyClause.ParseOrderBy(orderby);
}
}
return(response);
}
catch
{
return(null);
}
}
public void CreateCollection_From_OrderByNode_Succeeds()
{
// Arrange
ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>();
builder.EntitySet <SampleClass>("entityset");
IEdmModel model = builder.GetEdmModel();
IEdmEntityType sampleClassEntityType = model.SchemaElements.Single(t => t.Name == "SampleClass") as IEdmEntityType;
Assert.NotNull(sampleClassEntityType); // Guard
IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("entityset");
Assert.NotNull(entitySet); // Guard
ODataQueryOptionParser parser = new ODataQueryOptionParser(model, sampleClassEntityType, entitySet,
new Dictionary <string, string> {
{ "$orderby", "Property1 desc, Property2 asc" }
});
OrderByClause orderbyNode = parser.ParseOrderBy();
// Act
ICollection <OrderByNode> nodes = OrderByNode.CreateCollection(orderbyNode);
// Assert
Assert.False(nodes.OfType <OrderByItNode>().Any());
IEnumerable <OrderByPropertyNode> propertyNodes = nodes.OfType <OrderByPropertyNode>();
Assert.Equal(2, propertyNodes.Count());
Assert.Equal("Property1", propertyNodes.First().Property.Name);
Assert.Equal(OrderByDirection.Descending, propertyNodes.First().Direction);
Assert.Equal("Property1", propertyNodes.First().PropertyPath);
Assert.Equal("Property2", propertyNodes.Last().Property.Name);
Assert.Equal(OrderByDirection.Ascending, nodes.Last().Direction);
Assert.Equal("Property2", propertyNodes.Last().PropertyPath);
}
public async Task <IActionResult> GetPeople(
[FromRoute] string organizationId,
[FromQuery(Name = "$filter")] string filter = "",
[FromQuery(Name = "$orderby")] string orderBy = "",
[FromQuery(Name = "$top")] int top = 100,
[FromQuery(Name = "$skip")] int skip = 0)
{
try
{
ODataHelper <TeamMemberViewModel> oData = new ODataHelper <TeamMemberViewModel>();
string queryString = "";
if (HttpContext != null &&
HttpContext.Request != null &&
HttpContext.Request.QueryString != null &&
HttpContext.Request.QueryString.HasValue)
{
queryString = HttpContext.Request.QueryString.Value;
}
var newNode = oData.ParseOrderByQuery(queryString);
if (newNode == null)
{
newNode = new OrderByNode <TeamMemberViewModel>();
}
Guid orgId = Guid.Parse(organizationId);
var result = _membershipManager.GetPeopleInOrganization(orgId, newNode.PropertyName, newNode.Direction, skip, top);
return(Ok(result));
}
catch (Exception ex)
{
return(ex.GetActionResult());
}
}
/// <summary>
/// Apply $orderby parameter to query.
/// </summary>
/// <param name="query">
/// The OData aware query.
/// </param>
/// <param name="orderbyText">
/// The $orderby parameter text.
/// </param>
/// <param name="entitySetName">
/// The entity set name.
/// </param>
/// <typeparam name="T">
/// The query type param
/// </typeparam>
/// <returns>
/// The <see cref="ODataQuery{T}"/> query with applied order by parameter.
/// </returns>
/// <exception cref="ArgumentNullException">
/// Argument Null Exception
/// </exception>
public static ODataQueryOrdered <T> OrderBy <T>(this ODataQuery <T> query, string orderbyText, string entitySetName = null)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (orderbyText == null)
{
throw new ArgumentNullException(nameof(orderbyText));
}
IEdmModel edmModel = query.EdmModel;
ODataQueryOptionParser queryOptionParser = GetParser(
query,
entitySetName,
new Dictionary <string, string> {
{ "$orderby", orderbyText }
});
ODataSettings settings = query.ServiceProvider.GetRequiredService <ODataSettings>();
var orderByClause = queryOptionParser.ParseOrderBy();
orderByClause = TranslateParameterAlias(orderByClause, queryOptionParser);
ICollection <OrderByNode> nodes = OrderByNode.CreateCollection(orderByClause);
var validator = new OrderByQueryValidator(settings.DefaultQuerySettings);
validator.Validate(nodes, settings.ValidationSettings, edmModel);
IOrderedQueryable <T> result = (IOrderedQueryable <T>)OrderByBinder.OrderApplyToCore(query, settings.QuerySettings, nodes, edmModel);
return(new ODataQueryOrdered <T>(result, query.ServiceProvider));
}
public void Visit(OrderByNode node) => VisitInternal(node);
public void Visit(OrderByNode node) => Format(node, $"{string.Join(",", node.Fields)}");
public void Visit(OrderByNode node)
{
node.Inner[0].Accept(this);
Mode = Query.EvaluationMode.Aggregate;
}
public void Visit(OrderByNode node)
{
node.Inner[0].Accept(this);
Tree = new OrderByNode(Tree, node.Fields, node.Descending);
}
protected virtual void StripOrderBy(OrderByNode node, HashSet <QueryMethod> additionalQueryMethods)
{
var fieldName = GetFormattedFieldName(node.Field);
additionalQueryMethods.Add(new OrderByMethod(fieldName, node.FieldType, node.SortDirection));
}
public DetailedQueryNode(SelectNode select, FromNode from, WhereNode where, GroupByNode groupBy,
OrderByNode orderBy, SkipNode skip, TakeNode take, string returnVariableName)
: base(select, from, where, groupBy, orderBy, skip, take)
{
ReturnVariableName = returnVariableName;
}
/// <summary>
/// Creates a query tree for the given query elements
/// </summary>
/// <param name="match"><see cref="MatchNode"/> for matching log items</param>
/// <param name="parser"><see cref="IParser"/> for parsing log items</param>
/// <param name="filter">An <see cref="Expression"/> for filtering log items</param>
/// <param name="grouping">An enumerable of tuples of group names and grouping <see cref="Expression"/>s for grouping the log items</param>
/// <param name="selects">An enumerable of tuples of projection labels and <see cref="Expression"/>s for projecting log items</param>
/// <param name="order">An enumerable of tuples indicating sorting fields and sort order</param>
/// <param name="limit">The number of items to return</param>
/// <returns>A query tree for executing the query</returns>
private static Node CreateQueryTree(
MatchNode match,
IOption <Tuple <string, IParser> > parser,
IOption <Expression> filter,
IOption <IEnumerable <Tuple <string, Expression> > > grouping,
IOption <IEnumerable <Tuple <string, IAggregate> > > selects,
IOption <IEnumerable <Tuple <string, bool> > > order,
IOption <int> limit)
{
Node query = match;
if (!parser.IsEmpty)
{
query = new ParseNode(query, parser.Get().Item2, parser.Get().Item1);
}
if (!filter.IsEmpty)
{
query = new PredicateNode(query, filter.Get());
}
if (!grouping.IsEmpty)
{
var keyNames = grouping.Get().Select(g => g.Item1).ToArray();
var keyExpressions = grouping.Get().Select(g => g.Item2).ToArray();
if (selects.IsEmpty)
{
query = new GroupByNode(query, keyNames, keyExpressions, new string[0], new IAggregate[0]);
}
else
{
var aggregateNames = selects.Get().Select(s => s.Item1).ToArray();
var aggregates = selects.Get().Select(s => s.Item2).ToArray();
query = new GroupByNode(query, keyNames, keyExpressions, aggregateNames, aggregates);
}
}
else if (!selects.IsEmpty)
{
var aggregateNames = selects.Get().Select(s => s.Item1).ToArray();
var aggregates = selects.Get().Select(s => s.Item2).ToArray();
if (aggregates.All(a => a is ListAggregate))
{
query = new ProjectNode(query, aggregateNames, aggregates.Cast <ListAggregate>().Select(a => a.Expression).ToArray());
}
else
{
query = new AggregateNode(query, aggregateNames, aggregates);
}
}
if (!order.IsEmpty)
{
query = new OrderByNode(query, order.Get().Select(a => a.Item1).ToArray(), order.Get().Select(a => a.Item2).ToArray());
}
if (!limit.IsEmpty)
{
query = new LimitNode(query, limit.Get());
}
return(query);
}
protected virtual QueryNode VisitOrderBy(OrderByNode node, AzureQueryOptimizerState state)
{
return((QueryNode) new OrderByNode(this.Visit(node.SourceNode, state), node.Field, node.FieldType, node.SortDirection));
}
protected virtual void StripOrderBy(OrderByNode node, HashSet <QueryMethod> additionalQueryMethods)
{
string lowerInvariant = node.Field.ToLowerInvariant();
additionalQueryMethods.Add(new OrderByMethod(lowerInvariant.Replace(" ", "_"), node.FieldType, node.SortDirection));
}
public void Visit(OrderByNode node)
{
}
private static TreeNode BuildInnerTree(XElement element, TreeNode parentNode, Tree tree)
{
TreeNode treeNode = TreeNodeCreatorFactory.CreateTreeNode(element, tree);
if (treeNode == null)
{
return(null);
}
// Actions
XElement actionsElement = element.Element(TreeMarkupConstants.Namespace + "Actions");
if (actionsElement != null)
{
foreach (XElement actionElement in actionsElement.Elements())
{
ActionNode actionNode = ActionNodeCreatorFactory.CreateActionNode(actionElement, tree);
if (actionNode != null)
{
treeNode.AddActionNode(actionNode);
}
}
}
// OrderBys
XElement orderBysElement = element.Element(TreeMarkupConstants.Namespace + "OrderBy");
if (orderBysElement != null)
{
foreach (XElement orderByElement in orderBysElement.Elements())
{
OrderByNode orderByNode = OrderByNodeCreatorFactory.CreateOrderByNode(orderByElement, tree);
if (orderByNode != null)
{
treeNode.AddOrderByNode(orderByNode);
}
}
}
// Filters
XElement filtersElement = element.Element(TreeMarkupConstants.Namespace + "Filters");
if (filtersElement != null)
{
foreach (XElement filterElement in filtersElement.Elements())
{
FilterNode filterNode = FilterNodeCreatorFactory.CreateFilterNode(filterElement, tree);
if (filterNode != null)
{
treeNode.AddFilterNode(filterNode);
}
}
}
if (parentNode != null)
{
parentNode.AddChildTreeNode(treeNode);
}
// Children
XElement childrenElement = element.Element(TreeMarkupConstants.Namespace + "Children");
if (childrenElement != null)
{
foreach (XElement childElement in childrenElement.Elements())
{
BuildInnerTree(childElement, treeNode, tree);
}
}
treeNode.InitializeActions();
treeNode.InitializeOrderByes();
treeNode.InitializeFilters();
return(treeNode);
}
protected virtual QueryNode VisitOrderBy(OrderByNode node, ElasticSearchQueryOptimizerState state)
{
return(new OrderByNode(Visit(node.SourceNode, state), node.Field, node.FieldType, node.SortDirection));
}
