public override SqlObject VisitOrder_by_item([NotNull] sqlParser.Order_by_itemContext context)
{
Contract.Requires(context != null);
SqlScalarExpression expression = (SqlScalarExpression)this.Visit(context.scalar_expression());
bool isDescending = false;
if (context.sort_order() != null)
{
if (context.sort_order().K_ASC() != null)
{
isDescending = false;
}
else if (context.sort_order().K_DESC() != null)
{
isDescending = true;
}
else
{
throw new ArgumentOutOfRangeException($"Unknown sort order : {context.sort_order()}.");
}
}
return(SqlOrderByItem.Create(expression, isDescending));
}
private SqlOrderbyClause Substitute(SqlSelectSpec spec, SqlIdentifier inputParam, SqlOrderbyClause orderByClause)
{
if (orderByClause == null)
{
return(null);
}
if (spec is SqlSelectStarSpec)
{
return(orderByClause);
}
SqlSelectValueSpec selValue = spec as SqlSelectValueSpec;
if (selValue != null)
{
SqlScalarExpression replaced = selValue.Expression;
SqlOrderByItem[] substitutedItems = new SqlOrderByItem[orderByClause.OrderbyItems.Count];
for (int i = 0; i < substitutedItems.Length; ++i)
{
SqlScalarExpression substituted = SqlExpressionManipulation.Substitute(replaced, inputParam, orderByClause.OrderbyItems[i].Expression);
substitutedItems[i] = SqlOrderByItem.Create(substituted, orderByClause.OrderbyItems[i].IsDescending);
}
SqlOrderbyClause result = SqlOrderbyClause.Create(substitutedItems);
return(result);
}
throw new DocumentQueryException("Unexpected SQL select clause type: " + spec.Kind);
}
public override SqlObject VisitOrder_by_clause([NotNull] sqlParser.Order_by_clauseContext context)
{
Contract.Requires(context != null);
List <SqlOrderByItem> orderByItems = new List <SqlOrderByItem>();
foreach (sqlParser.Order_by_itemContext orderByItemContext in context.order_by_items().order_by_item())
{
SqlScalarExpression expression = (SqlScalarExpression)this.Visit(orderByItemContext.scalar_expression());
bool isDescending = false;
if (orderByItemContext.sort_order() != null)
{
if (orderByItemContext.sort_order().K_ASC() != null)
{
isDescending = false;
}
else if (orderByItemContext.sort_order().K_DESC() != null)
{
isDescending = true;
}
else
{
throw new ArgumentOutOfRangeException($"Unknown sort order : {orderByItemContext.sort_order()}.");
}
}
SqlOrderByItem orderByItem = SqlOrderByItem.Create(expression, isDescending);
orderByItems.Add(orderByItem);
}
return(SqlOrderbyClause.Create(orderByItems));
}
public virtual void Visiting(SqlOrderByItem orderByItem)
{
orderByItem.SqlExpression.Accept(this);
if (orderByItem.Descending)
{
sqlBuilder.Append(" Desc");
}
sqlBuilder.Append(", ");
}
public override SqlObject Visit(SqlOrderbyClause sqlOrderByClause)
{
SqlOrderByItem[] items = new SqlOrderByItem[sqlOrderByClause.OrderbyItems.Length];
for (int i = 0; i < sqlOrderByClause.OrderbyItems.Length; i++)
{
items[i] = sqlOrderByClause.OrderbyItems[i].Accept(this) as SqlOrderByItem;
}
return(SqlOrderbyClause.Create(items));
}
public override void Visit(SqlOrderByItem sqlOrderByItem)
{
sqlOrderByItem.Expression.Accept(this);
if (sqlOrderByItem.IsDescending)
{
this.writer.Write(" DESC");
}
else
{
this.writer.Write(" ASC");
}
}
public override SqlObject VisitOrder_by_clause([NotNull] sqlParser.Order_by_clauseContext context)
{
Contract.Requires(context != null);
List <SqlOrderByItem> orderByItems = new List <SqlOrderByItem>();
foreach (sqlParser.Order_by_itemContext orderByItemContext in context.order_by_items().order_by_item())
{
SqlOrderByItem orderByItem = (SqlOrderByItem)this.VisitOrder_by_item(orderByItemContext);
orderByItems.Add(orderByItem);
}
return(SqlOrderByClause.Create(orderByItems.ToImmutableArray()));
}
public override int Visit(SqlOrderByItem sqlOrderByItem)
{
int hashCode = SqlOrderbyItemHashCode;
hashCode = CombineHashes(hashCode, sqlOrderByItem.Expression.Accept(this));
if (sqlOrderByItem.IsDescending)
{
hashCode = CombineHashes(hashCode, SqlOrderbyItemDescendingHashCode);
}
else
{
hashCode = CombineHashes(hashCode, SqlOrderbyItemAscendingHashCode);
}
return(hashCode);
}
public override bool Visit(SqlOrderByItem first, SqlObject secondAsObject)
{
if (!(secondAsObject is SqlOrderByItem second))
{
return(false);
}
if (first.IsDescending != second.IsDescending)
{
return(false);
}
if (!Equals(first.Expression, second.Expression))
{
return(false);
}
return(true);
}
public override SqlObject Visit(SqlOrderByItem sqlOrderByItem)
{
return(SqlOrderByItem.Create(
sqlOrderByItem.Expression.Accept(this) as SqlScalarExpression,
sqlOrderByItem.IsDescending));
}
public override void Visit(SqlOrderByItem codeObject)
{
codeObject.Expression.Accept(this);
}
public abstract TOutput Visit(SqlOrderByItem sqlObject, TArg input);
public abstract TResult Visit(SqlOrderByItem sqlObject);
public virtual void Visited(SqlOrderByItem orderByItem)
{
}
private static IEnumerable <CosmosElement> ExecuteOrderByClause(
IEnumerable <CosmosElement> dataSource,
SqlOrderByClause sqlOrderByClause,
IReadOnlyDictionary <string, PartitionKeyRange> ridToPartitionKeyRange)
{
// Sort by the columns left to right
SqlOrderByItem firstItem = sqlOrderByClause.OrderByItems[0];
// Since we don't supply an explicit index on the policy undefined items don't show up in the sort order
if (sqlOrderByClause.OrderByItems.Length == 1)
{
dataSource = dataSource.Where(element => firstItem.Expression.Accept(
ScalarExpressionEvaluator.Singleton,
element) != Undefined);
}
IOrderedEnumerable <CosmosElement> orderedDataSource;
if (firstItem.IsDescending)
{
orderedDataSource = dataSource.OrderByDescending(
element => firstItem.Expression.Accept(
ScalarExpressionEvaluator.Singleton,
element));
}
else
{
orderedDataSource = dataSource.OrderBy(
element => firstItem.Expression.Accept(
ScalarExpressionEvaluator.Singleton,
element));
}
foreach (SqlOrderByItem sqlOrderByItem in sqlOrderByClause.OrderByItems.Skip(1))
{
if (sqlOrderByItem.IsDescending)
{
orderedDataSource = orderedDataSource.ThenByDescending(
element => sqlOrderByItem.Expression.Accept(
ScalarExpressionEvaluator.Singleton,
element));
}
else
{
orderedDataSource = orderedDataSource.ThenBy(
element => sqlOrderByItem.Expression.Accept(
ScalarExpressionEvaluator.Singleton,
element));
}
}
// Grab from the left most partition first
orderedDataSource = orderedDataSource
.ThenBy((element) =>
{
string rid = ((CosmosString)((CosmosObject)element)["_rid"]).Value;
PartitionKeyRange partitionKeyRange = ridToPartitionKeyRange[rid];
return(partitionKeyRange.MinInclusive);
},
StringComparer.Ordinal);
// Break all final ties within partition by document id
if (firstItem.IsDescending)
{
orderedDataSource = orderedDataSource
.ThenByDescending(element => ResourceId.Parse(((CosmosString)((CosmosObject)element)["_rid"]).Value).Document);
}
else
{
orderedDataSource = orderedDataSource
.ThenBy(element => ResourceId.Parse(((CosmosString)((CosmosObject)element)["_rid"]).Value).Document);
}
return(orderedDataSource);
}
public abstract void Visit(SqlOrderByItem sqlObject);
public override void Visit(SqlOrderByItem codeObject)
{
Format(codeObject);
}
