/// <summary> /// Parse compute expression text into a token. /// </summary> /// <returns>The lexical token representing the compute expression text.</returns> internal ComputeExpressionToken ParseComputeExpression() { // expression QueryToken expression = this.ParseExpression(); // "as" alias StringLiteralToken alias = this.ParseAggregateAs(); return(new ComputeExpressionToken(expression, alias.Text)); }
private StringLiteralToken ParseAggregateAs() { if (!TokenIdentifierIs(ExpressionConstants.KeywordAs)) { throw ParseError(ODataErrorStrings.UriQueryExpressionParser_AsExpected(this.lexer.CurrentToken.Position, this.lexer.ExpressionText)); } lexer.NextToken(); var alias = new StringLiteralToken(lexer.CurrentToken.Text); lexer.NextToken(); return(alias); }
internal AggregateTokenBase ParseAggregateExpression() { try { this.parseAggregateExpresionDepth++; // expression QueryToken expression = ParseLogicalOr(); if (this.lexer.CurrentToken.Kind == ExpressionTokenKind.OpenParen) { // When there's a parenthesis after the expression we have a entity set aggregation. // The syntax is the same as the aggregate expression itself, so we recurse on ParseAggregateExpressions. this.aggregateExpressionParents.Push(expression); List <AggregateTokenBase> statements = ParseAggregateExpressions(); this.aggregateExpressionParents.Pop(); return(new EntitySetAggregateToken(expression, statements)); } AggregationMethodDefinition verb; // "with" verb EndPathToken endPathExpression = expression as EndPathToken; if (endPathExpression != null && endPathExpression.Identifier == ExpressionConstants.QueryOptionCount) { // e.g. aggregate($count as Count) verb = AggregationMethodDefinition.VirtualPropertyCount; } else { // e.g. aggregate(UnitPrice with sum as Total) verb = this.ParseAggregateWith(); } // "as" alias StringLiteralToken alias = this.ParseAggregateAs(); return(new AggregateExpressionToken(expression, verb, alias.Text)); } finally { this.parseAggregateExpresionDepth--; } }
/// <summary> /// Parses the primary expressions. /// </summary> /// <returns>The lexical token representing the expression.</returns> private QueryToken ParsePrimary() { QueryToken expr = null; this.RecurseEnter(); switch (this.lexer.CurrentToken.Kind) { case ExpressionTokenKind.OpenParen: expr = this.ParseParenExpression(); break; case ExpressionTokenKind.StringLiteral: expr = new StringLiteralToken(this.lexer.CurrentToken.Text); this.lexer.NextToken(); break; default: throw new ODataException(ODataErrorStrings.UriQueryExpressionParser_ExpressionExpected(this.lexer.CurrentToken.Position, this.lexer.ExpressionText)); } this.RecurseLeave(); return(expr); }
/// <summary> /// Binds a StringLiteral token. /// </summary> /// <param name="stringLiteralToken">The StringLiteral token to bind.</param> /// <returns>The bound StringLiteral token.</returns> protected virtual QueryNode BindStringLiteral(StringLiteralToken stringLiteralToken) { return(new SearchTermNode(stringLiteralToken.Text)); }