public SqlToken GenerateSqlToken(SelectCommandContext sqlCommandContext) { var result = new OrderByToken(GenerateOrderByIndex(sqlCommandContext)); foreach (var orderByItem in sqlCommandContext.GetOrderByContext().GetItems()) { string columnLabel; if (orderByItem.GetSegment() is ColumnOrderByItemSegment columnOrderByItemSegment) { var quoteCharacterEnum = columnOrderByItemSegment.GetColumn().GetIdentifier().GetQuoteCharacter(); QuoteCharacter quoteCharacter = QuoteCharacter.Get(quoteCharacterEnum); columnLabel = quoteCharacter.GetStartDelimiter() + columnOrderByItemSegment.GetText() + quoteCharacter.GetEndDelimiter(); } else if (orderByItem.GetSegment() is ExpressionOrderByItemSegment expressionOrderByItemSegment) { columnLabel = expressionOrderByItemSegment.GetText(); } else { columnLabel = $"{orderByItem.GetIndex()}"; // String.valueOf(each.getIndex()); } result.ColumnLabels.Add(columnLabel); result.OrderDirections.Add(orderByItem.GetSegment().GetOrderDirection()); } return(result); }
public void OrderByQueryTokenDefaultTest() { var expression = new InnerPathToken(string.Empty, null, null); OrderByToken orderby = new OrderByToken(expression, OrderByDirection.Ascending); this.Assert.AreEqual(QueryTokenKind.OrderBy, orderby.Kind, "The InternalKind property has an unexpected value."); this.Assert.AreEqual(OrderByDirection.Ascending, orderby.Direction, "The Direction property should be Ascending."); this.Assert.AreEqual(expression, orderby.Expression, "The Expression property has an unexpected value."); }
public void OrderByQueryTokenDefaultTest() { var expression = new InnerPathToken(string.Empty, null, null); OrderByToken orderby = new OrderByToken(expression, OrderByDirection.Ascending); this.Assert.AreEqual(QueryTokenKind.OrderBy, orderby.Kind, "The InternalKind property has an unexpected value."); this.Assert.AreEqual(OrderByDirection.Ascending, orderby.Direction, "The Direction property should be Ascending."); this.Assert.AreEqual(expression, orderby.Expression, "The Expression property has an unexpected value."); }
/// <summary> /// Write the orderby token as URI part to this builder. /// </summary> /// <param name="orderBy">To write as URI part.</param> private void WriteOrderBy(OrderByToken orderBy) { ExceptionUtils.CheckArgumentNotNull(orderBy, "orderBy"); this.WriteQuery(orderBy.Expression); if (orderBy.Direction == OrderByDirection.Descending) { this.builder.Append(ExpressionConstants.SymbolEscapedSpace); this.builder.Append(ExpressionConstants.KeywordDescending); } }
public void NestedOrderbyInSelectIsAllowed(string optionsText) { // Arrange & Act SelectTermToken selectTerm = this.ParseSelectOptions(optionsText); // Assert Assert.NotNull(selectTerm); Assert.NotNull(selectTerm.OrderByOptions); OrderByToken orderBy = Assert.Single(selectTerm.OrderByOptions); orderBy.Expression.ShouldBeEndPathToken("two"); }
public void ParseOrderByThisInSelectWorks(string queryString, OrderByDirection orderByDirection) { // Arrange & Act SelectToken selectToken = ParseSelectClause(queryString); // Assert Assert.NotNull(selectToken); SelectTermToken selectTermToken = Assert.Single(selectToken.SelectTerms); selectTermToken.PathToProperty.ShouldBeNonSystemToken("Emails"); Assert.NotNull(selectTermToken.OrderByOptions); OrderByToken orderBy = Assert.Single(selectTermToken.OrderByOptions); orderBy.Expression.ShouldBeRangeVariableToken("$this"); Assert.Equal(orderByDirection, orderBy.Direction); }
public void OrderBySetCorrectly() { OrderByToken orderBy = new OrderByToken(new LiteralToken(1), OrderByDirection.Descending); ExpandTermToken expandTerm = new ExpandTermToken(new NonSystemToken("stuff", null, null), null /*filterOption*/, new OrderByToken[] { orderBy }, null /*topOption*/, null /*skipOption*/, null /*countQueryOption*/, null /*levelsOption*/, null /*searchOption*/, null /*selectOption*/, null /*expandOption*/); expandTerm.OrderByOptions.Single().Kind.Should().Be(QueryTokenKind.OrderBy); expandTerm.OrderByOptions.Single().Expression.ShouldBeLiteralQueryToken(1); }
public void ParseNestedOrderByAndSearchInSelectWorks() { // Arrange & Act SelectToken selectToken = ParseSelectClause("Address($orderby=abc;$search=xyz)"); // Assert Assert.NotNull(selectToken); SelectTermToken selectTermToken = Assert.Single(selectToken.SelectTerms); selectTermToken.PathToProperty.ShouldBeNonSystemToken("Address"); Assert.NotNull(selectTermToken.OrderByOptions); OrderByToken orderBy = Assert.Single(selectTermToken.OrderByOptions); orderBy.Expression.ShouldBeEndPathToken("abc"); Assert.NotNull(selectTermToken.SearchOption); selectTermToken.SearchOption.ShouldBeStringLiteralToken("xyz"); }
public void InnerOrderBySetCorrectly() { // Arrange & Act OrderByToken orderBy = new OrderByToken(new LiteralToken(42), OrderByDirection.Descending); SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null), null, new OrderByToken[] { orderBy }, null, null, null, null, null, null); // Assert Assert.NotNull(selectTerm.OrderByOptions); OrderByToken expectedOrderBy = Assert.Single(selectTerm.OrderByOptions); Assert.Equal(QueryTokenKind.OrderBy, expectedOrderBy.Kind); Assert.NotNull(expectedOrderBy.Expression); LiteralToken literalToken = Assert.IsType <LiteralToken>(expectedOrderBy.Expression); Assert.Equal(QueryTokenKind.Literal, literalToken.Kind); Assert.Equal(42, literalToken.Value); }
public void OrderBySetCorrectly() { // Arrange & Act OrderByToken orderBy = new OrderByToken(new LiteralToken(1), OrderByDirection.Descending); ExpandTermToken expandTerm = new ExpandTermToken(new NonSystemToken("stuff", null, null), null /*filterOption*/, new OrderByToken[] { orderBy }, null /*topOption*/, null /*skipOption*/, null /*countQueryOption*/, null /*levelsOption*/, null /*searchOption*/, null /*selectOption*/, null /*expandOption*/); // Assert Assert.NotNull(expandTerm.OrderByOptions); OrderByToken orderByToken = Assert.Single(expandTerm.OrderByOptions); Assert.Equal(QueryTokenKind.OrderBy, orderByToken.Kind); orderByToken.Expression.ShouldBeLiteralQueryToken(1); }
/// <summary> /// Parses the $orderby expression. /// </summary> /// <param name="orderBy">The $orderby expression string to parse.</param> /// <returns>The enumeraion of lexical tokens representing order by tokens.</returns> internal IEnumerable <OrderByToken> ParseOrderBy(string orderBy) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(orderBy != null, "orderBy != null"); this.recursionDepth = 0; this.lexer = CreateLexerForFilterOrOrderByExpression(orderBy); List <OrderByToken> orderByTokens = new List <OrderByToken>(); while (true) { QueryToken expression = this.ParseExpression(); bool ascending = true; if (this.TokenIdentifierIs(ExpressionConstants.KeywordAscending)) { this.lexer.NextToken(); } else if (this.TokenIdentifierIs(ExpressionConstants.KeywordDescending)) { this.lexer.NextToken(); ascending = false; } OrderByToken orderByToken = new OrderByToken(expression, ascending ? OrderByDirection.Ascending : OrderByDirection.Descending); orderByTokens.Add(orderByToken); if (this.lexer.CurrentToken.Kind != ExpressionTokenKind.Comma) { break; } this.lexer.NextToken(); } this.lexer.ValidateToken(ExpressionTokenKind.End); return(new ReadOnlyCollection <OrderByToken>(orderByTokens)); }
/// <summary> /// Processes the specified order-by token. /// </summary> /// <param name="state">State to use for binding.</param> /// <param name="thenBy"> The next OrderBy node, or null if there is no orderby after this.</param> /// <param name="orderByToken">The order-by token to bind.</param> /// <returns>Returns the combined entityCollection including the ordering.</returns> private OrderByClause ProcessSingleOrderBy(BindingState state, OrderByClause thenBy, OrderByToken orderByToken) { ExceptionUtils.CheckArgumentNotNull(state, "state"); ExceptionUtils.CheckArgumentNotNull(orderByToken, "orderByToken"); QueryNode expressionNode = this.bindMethod(orderByToken.Expression); // The order-by expressions need to be primitive / enumeration types SingleValueNode expressionResultNode = expressionNode as SingleValueNode; if (expressionResultNode == null || (expressionResultNode.TypeReference != null && !expressionResultNode.TypeReference.IsODataPrimitiveTypeKind() && !expressionResultNode.TypeReference.IsODataEnumTypeKind() && !expressionResultNode.TypeReference.IsODataTypeDefinitionTypeKind())) { throw new ODataException(ODataErrorStrings.MetadataBinder_OrderByExpressionNotSingleValue); } OrderByClause orderByNode = new OrderByClause( thenBy, expressionResultNode, orderByToken.Direction, state.ImplicitRangeVariable); return orderByNode; }
/// <inheritdoc /> public void OrderByDistanceDescending(string fieldName, double latitude, double longitude) { OrderByTokens.AddLast(OrderByToken.CreateDistanceDescending(fieldName, AddQueryParameter(latitude), AddQueryParameter(longitude))); }
/// <inheritdoc /> public void OrderByDistanceDescending(string fieldName, string shapeWkt) { OrderByTokens.AddLast(OrderByToken.CreateDistanceDescending(fieldName, AddQueryParameter(shapeWkt))); }
public void OrderBySetCorrectly() { OrderByToken orderBy = new OrderByToken(new LiteralToken(1), OrderByDirection.Descending); ExpandTermToken expandTerm = new ExpandTermToken(new NonSystemToken("stuff", null, null), null /*filterOption*/, new OrderByToken[] { orderBy }, null /*topOption*/, null /*skipOption*/, null /*countQueryOption*/, null /*levelsOption*/, null /*searchOption*/, null /*selectOption*/, null /*expandOption*/); expandTerm.OrderByOptions.Single().Kind.Should().Be(QueryTokenKind.OrderBy); expandTerm.OrderByOptions.Single().Expression.ShouldBeLiteralQueryToken(1); }
private static void VerifyOrderByQueryTokensAreEqual(OrderByToken expected, OrderByToken actual, AssertionHandler assert) { assert.AreEqual(expected.Direction, actual.Direction, "The Direction of the order by doesn't match the expected one."); VerifyQueryTokensAreEqual(expected.Expression, actual.Expression, assert); }
/// <summary> /// Processes the specified order-by token. /// </summary> /// <param name="state">State to use for binding.</param> /// <param name="thenBy"> The next OrderBy node, or null if there is no orderby after this.</param> /// <param name="orderByToken">The order-by token to bind.</param> /// <returns>Returns the combined entityCollection including the ordering.</returns> private OrderByClause ProcessSingleOrderBy(BindingState state, OrderByClause thenBy, OrderByToken orderByToken) { ExceptionUtils.CheckArgumentNotNull(state, "state"); ExceptionUtils.CheckArgumentNotNull(orderByToken, "orderByToken"); QueryNode expressionNode = this.bindMethod(orderByToken.Expression); // The order-by expressions need to be primitive / enumeration types SingleValueNode expressionResultNode = expressionNode as SingleValueNode; if (expressionResultNode == null || (expressionResultNode.TypeReference != null && !expressionResultNode.TypeReference.IsODataPrimitiveTypeKind() && !expressionResultNode.TypeReference.IsODataEnumTypeKind())) { throw new ODataException(ODataErrorStrings.MetadataBinder_OrderByExpressionNotSingleValue); } OrderByClause orderByNode = new OrderByClause( thenBy, expressionResultNode, orderByToken.Direction, state.ImplicitRangeVariable); return(orderByNode); }
/// <summary> /// Visits an OrderByToken /// </summary> /// <param name="tokenIn">The OrderByToken to bind</param> /// <returns>An OrderByClause bound to this OrderByToken</returns> public virtual T Visit(OrderByToken tokenIn) { throw new NotImplementedException(); }
private static void VerifyOrderByQueryTokensAreEqual(OrderByToken expected, OrderByToken actual, AssertionHandler assert) { assert.AreEqual(expected.Direction, actual.Direction, "The Direction of the order by doesn't match the expected one."); VerifyQueryTokensAreEqual(expected.Expression, actual.Expression, assert); }
/// <inheritdoc /> public void OrderByDistanceDescending(string fieldName, double latitude, double longitude, double roundFactor) { var roundFactorParameterName = roundFactor == 0 ? null : AddQueryParameter(roundFactor); OrderByTokens.AddLast(OrderByToken.CreateDistanceDescending(fieldName, AddQueryParameter(latitude), AddQueryParameter(longitude), roundFactorParameterName)); }
/// <summary> /// Build the list of expand options /// Depends on whether options are allowed or not. /// </summary> /// <param name="isInnerTerm">is this an inner expand term</param> /// <param name="pathToken">the current level token, as a PathToken</param> /// <returns>An expand term token based on the path token, and all available expand options.</returns> internal override ExpandTermToken BuildExpandTermToken(bool isInnerTerm, PathSegmentToken pathToken) { DebugUtils.CheckNoExternalCallers(); QueryToken filterOption = null; OrderByToken orderByOption = null; long? topOption = null; long? skipOption = null; InlineCountKind?inlineCountOption = null; SelectToken selectOption = null; ExpandToken expandOption = null; if (this.Lexer.CurrentToken.Kind == ExpressionTokenKind.OpenParen) { // could have a filter, orderby, etc. or another select and expand. while (this.Lexer.PeekNextToken().Kind != ExpressionTokenKind.CloseParen) { switch (this.Lexer.NextToken().Text) { case ExpressionConstants.QueryOptionFilter: { // advance to the equal sign this.Lexer.NextToken(); string filterText = this.ReadQueryOption(); UriQueryExpressionParser filterParser = new UriQueryExpressionParser(this.MaxDepth); filterOption = filterParser.ParseFilter(filterText); break; } case ExpressionConstants.QueryOptionOrderby: { // advance to the equal sign this.Lexer.NextToken(); string orderByText = this.ReadQueryOption(); UriQueryExpressionParser orderbyParser = new UriQueryExpressionParser(this.MaxDepth); orderByOption = orderbyParser.ParseOrderBy(orderByText).Single(); break; } case ExpressionConstants.QueryOptionTop: { // advance to the equal sign this.Lexer.NextToken(); string topText = this.ReadQueryOption(); // TryParse requires a non-nullable long. long top; if (!long.TryParse(topText, out top)) { throw new ODataException(ODataErrorStrings.UriSelectParser_InvalidTopOption(topText)); } topOption = top; break; } case ExpressionConstants.QueryOptionSkip: { // advance to the equal sign this.Lexer.NextToken(); string skipText = this.ReadQueryOption(); // TryParse requires a non-nullable long. long skip; if (!long.TryParse(skipText, out skip)) { throw new ODataException(ODataErrorStrings.UriSelectParser_InvalidSkipOption(skipText)); } skipOption = skip; break; } case ExpressionConstants.QueryOptionInlineCount: { // advance to the equal sign this.Lexer.NextToken(); string inlineCountText = this.ReadQueryOption(); switch (inlineCountText) { case ExpressionConstants.InlineCountNone: { inlineCountOption = InlineCountKind.None; break; } case ExpressionConstants.InlineCountAllPages: { inlineCountOption = InlineCountKind.AllPages; break; } default: { throw new ODataException(ODataErrorStrings.UriSelectParser_TermIsNotValid(this.Lexer.ExpressionText)); } } break; } case ExpressionConstants.QueryOptionSelect: { // advance to the equal sign this.Lexer.NextToken(); selectOption = this.ParseSelect(); break; } case ExpressionConstants.QueryOptionExpand: { // advance to the equal sign this.Lexer.NextToken(); expandOption = this.ParseExpand(); break; } default: { throw new ODataException(ODataErrorStrings.UriSelectParser_TermIsNotValid(this.Lexer.ExpressionText)); } } } } else if (this.IsNotEndOfTerm(isInnerTerm)) { throw new ODataException(ODataErrorStrings.UriSelectParser_TermIsNotValid(this.Lexer.ExpressionText)); } return(new ExpandTermToken(pathToken, filterOption, orderByOption, topOption, skipOption, inlineCountOption, selectOption, expandOption)); }
/// <inheritdoc /> public void OrderByDistanceDescending(string fieldName, string shapeWkt, double roundFactor) { string factorParamName = roundFactor == 0 ? null : AddQueryParameter(roundFactor); OrderByTokens.AddLast(OrderByToken.CreateDistanceDescending(fieldName, AddQueryParameter(shapeWkt), factorParamName)); }
/// <summary> /// Parses the $orderby expression. /// </summary> /// <param name="orderBy">The $orderby expression string to parse.</param> /// <returns>The enumeraion of lexical tokens representing order by tokens.</returns> internal IEnumerable<OrderByToken> ParseOrderBy(string orderBy) { Debug.Assert(orderBy != null, "orderBy != null"); this.recursionDepth = 0; this.lexer = CreateLexerForFilterOrOrderByOrApplyExpression(orderBy); List<OrderByToken> orderByTokens = new List<OrderByToken>(); while (true) { QueryToken expression = this.ParseExpression(); bool ascending = true; if (this.TokenIdentifierIs(ExpressionConstants.KeywordAscending)) { this.lexer.NextToken(); } else if (this.TokenIdentifierIs(ExpressionConstants.KeywordDescending)) { this.lexer.NextToken(); ascending = false; } OrderByToken orderByToken = new OrderByToken(expression, ascending ? OrderByDirection.Ascending : OrderByDirection.Descending); orderByTokens.Add(orderByToken); if (this.lexer.CurrentToken.Kind != ExpressionTokenKind.Comma) { break; } this.lexer.NextToken(); } this.lexer.ValidateToken(ExpressionTokenKind.End); return new ReadOnlyCollection<OrderByToken>(orderByTokens); }
public Expression Visit(OrderByToken tokenIn) { throw new NotImplementedException(); }
public bool Visit(OrderByToken tokenIn) { throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, "QueryToken of type '{0}' is not supported.", tokenIn.Kind)); }