import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
/**
 * Converts {@link OrderByItem} to {@link Sort} needed for
 * {@link Pagination}.
 * 
 * @param orderByItem
 *            order by item
 * @return sort instance, or null in case order by item wasn't specific type
 */
protected Sort toSort(OrderByItem orderByItem) {
    Expression expression = orderByItem.getExpression();
    if (expression instanceof Member) {
        UriInfoResource resourcePath = ((Member) expression).getResourcePath();
        UriResource uriResource = resourcePath.getUriResourceParts().get(0);
        if (uriResource instanceof UriResourcePrimitiveProperty) {
            EdmProperty edmProperty = ((UriResourcePrimitiveProperty) uriResource)
                    .getProperty();
            String property = edmProperty.getName();
            if (edmProperty instanceof ElasticEdmProperty) {
                ElasticEdmProperty entityTypeProperty = (ElasticEdmProperty) edmProperty;
                property = addKeywordIfNeeded(entityTypeProperty.getEField(),
                        entityTypeProperty.getAnnotations());
            }
            return new Sort(property,
                    orderByItem.isDescending() ? Sort.Direction.DESC : Sort.Direction.ASC);
        }
    }
    return null;
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
public void accept(Expression expr) {
    if (expr instanceof Alias) {
        visit((Alias) expr);
    } else if (expr instanceof Binary) {
        visit((Binary) expr);
    } else if (expr instanceof Enumeration) {
        visit((Enumeration) expr);
    } else if (expr instanceof LambdaRef) {
        visit((LambdaRef) expr);
    } else if (expr instanceof Literal) {
        visit((Literal) expr);
    } else if (expr instanceof Member) {
        visit((Member) expr);
    } else if (expr instanceof Method) {
        visit((Method) expr);
    } else if (expr instanceof TypeLiteral) {
        visit((TypeLiteral) expr);
    } else if (expr instanceof Unary) {
        visit((Unary) expr);
    }
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
@Test
public void binaryExpression() throws Exception {
  Expression expressionLeft = new LiteralImpl("2", odata.createPrimitiveTypeInstance(EdmPrimitiveTypeKind.Byte));
  Expression expressionRight = new LiteralImpl("-1", odata.createPrimitiveTypeInstance(EdmPrimitiveTypeKind.SByte));

  BinaryImpl expression = new BinaryImpl(expressionLeft, BinaryOperatorKind.SUB, expressionRight,
      odata.createPrimitiveTypeInstance(EdmPrimitiveTypeKind.Byte));

  assertEquals(expressionLeft, expression.getLeftOperand());
  assertEquals(expressionRight, expression.getRightOperand());
  assertEquals(BinaryOperatorKind.SUB, expression.getOperator());
  assertEquals(odata.createPrimitiveTypeInstance(EdmPrimitiveTypeKind.Byte), expression.getType());

  String output = expression.accept(new FilterTreeToText());
  assertEquals("<<2> sub <-1>>", output);
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
public FilterValidator isParameterText(final int parameterIndex, final String parameterText)
    throws ExpressionVisitException, ODataApplicationException {

  if (curExpression instanceof MethodImpl) {
    MethodImpl methodCall = (MethodImpl) curExpression;

    Expression parameter = methodCall.getParameters().get(parameterIndex);
    String actualParameterText = FilterTreeToText.Serialize(parameter);
    assertEquals(parameterText, actualParameterText);
  } else if (curExpression instanceof MemberImpl) {
    final MemberImpl member = (MemberImpl) curExpression;
    final List<UriResource> uriResourceParts = member.getResourcePath().getUriResourceParts();

    if (!uriResourceParts.isEmpty() && uriResourceParts.get(0) instanceof UriResourceFunctionImpl) {
      assertEquals(parameterText, ((UriResourceFunctionImpl) uriResourceParts.get(0)).getParameters()
          .get(parameterIndex).getText());
    } else {
      fail("Current expression is not a method or function");
    }
  } else {
    fail("Current expression is not a method or function");
  }

  return this;
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
private Expression parseExprRel() throws UriParserException, UriValidationException {
  if (tokenizer.next(TokenKind.IsofMethod)) {
    // The isof method is a terminal.  So no further operators are allowed.
    return parseIsOfOrCastMethod(MethodKind.ISOF);
  } else {
    Expression left = parseExprAdd();
    TokenKind operatorTokenKind = ParserHelper.next(tokenizer,
        TokenKind.GreaterThanOperator, TokenKind.GreaterThanOrEqualsOperator,
        TokenKind.LessThanOperator, TokenKind.LessThanOrEqualsOperator);
    // Null for everything other than GT or GE or LT or LE
    while (operatorTokenKind != null) {
      final Expression right = parseExprAdd();
      checkRelationTypes(left, right);
      left = new BinaryImpl(left, tokenToBinaryOperator.get(operatorTokenKind), right,
          odata.createPrimitiveTypeInstance(EdmPrimitiveTypeKind.Boolean));
      operatorTokenKind = ParserHelper.next(tokenizer,
          TokenKind.GreaterThanOperator, TokenKind.GreaterThanOrEqualsOperator,
          TokenKind.LessThanOperator, TokenKind.LessThanOrEqualsOperator);
    }
    return left;
  }
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
private Expression parseIsOfOrCastMethod(final MethodKind kind) throws UriParserException, UriValidationException {
  // The TokenKind 'IsOfMethod' consumes also the opening parenthesis.
  // The first parameter could be an expression or a type literal.
  List<Expression> parameters = new ArrayList<Expression>();
  ParserHelper.bws(tokenizer);
  parameters.add(parseExpression());
  if (!(parameters.get(0) instanceof TypeLiteral)) {
    // The first parameter is not a type literal, so there must be a second parameter.
    ParserHelper.bws(tokenizer);
    ParserHelper.requireNext(tokenizer, TokenKind.COMMA);
    ParserHelper.bws(tokenizer);
    parameters.add(parseExpression());
    ParserHelper.bws(tokenizer);
    // The second parameter must be a type literal.
    if (!(parameters.get(1) instanceof TypeLiteral)) {
      throw new UriParserSemanticException("Type literal expected.",
          UriParserSemanticException.MessageKeys.INCOMPATIBLE_TYPE_FILTER);
    }
  }

  ParserHelper.requireNext(tokenizer, TokenKind.CLOSE);
  return new MethodImpl(kind, parameters);
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
private Expression parseExprMul() throws UriParserException, UriValidationException {
  Expression left = parseExprUnary();
  TokenKind operatorTokenKind = ParserHelper.next(tokenizer,
      TokenKind.MulOperator, TokenKind.DivOperator, TokenKind.ModOperator);
  // Null for everything other than MUL or DIV or MOD
  while (operatorTokenKind != null) {
    checkNumericType(left);
    final Expression right = parseExprUnary();
    checkNumericType(right);
    left = new BinaryImpl(left, tokenToBinaryOperator.get(operatorTokenKind), right,
        odata.createPrimitiveTypeInstance(EdmPrimitiveTypeKind.Double));
    operatorTokenKind = ParserHelper.next(tokenizer,
        TokenKind.MulOperator, TokenKind.DivOperator, TokenKind.ModOperator);
  }
  return left;
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
private Expression parsePrimitive(final TokenKind primitiveTokenKind) throws UriParserException {
  final String primitiveValueLiteral = tokenizer.getText();
  if (primitiveTokenKind == TokenKind.EnumValue) {
    return createEnumExpression(primitiveValueLiteral);
  } else {
    EdmPrimitiveTypeKind primitiveTypeKind = ParserHelper.tokenToPrimitiveType.get(primitiveTokenKind);
    if (primitiveTypeKind == EdmPrimitiveTypeKind.Int64) {
      primitiveTypeKind = determineIntegerType(primitiveValueLiteral);
    }

    final EdmPrimitiveType type = primitiveTypeKind == null ?
        // Null handling
        null :
        odata.createPrimitiveTypeInstance(primitiveTypeKind);
    return new LiteralImpl(primitiveValueLiteral, type);
  }
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
private UriResourcePartTyped parseLambdaRest(final TokenKind lastTokenKind, final UriResourcePartTyped lastResource)
    throws UriParserException, UriValidationException {

  ParserHelper.requireNext(tokenizer, TokenKind.OPEN);
  if (lastTokenKind == TokenKind.ANY && tokenizer.next(TokenKind.CLOSE)) {
    return new UriResourceLambdaAnyImpl(null, null);
  }
  ParserHelper.requireNext(tokenizer, TokenKind.ODataIdentifier);
  final String lambbdaVariable = tokenizer.getText();
  ParserHelper.requireNext(tokenizer, TokenKind.COLON);
  lambdaVariables.addFirst(new UriResourceLambdaVarImpl(lambbdaVariable,
      lastResource == null ? referringType : lastResource.getType()));
  // The ABNF suggests that the "lambaPredicateExpr" must contain at least one lambdaVariable,
  // so arguably this could be checked in expression parsing or later in validation.
  final Expression lambdaPredicateExpr = parseExpression();
  lambdaVariables.removeFirst();
  ParserHelper.requireNext(tokenizer, TokenKind.CLOSE);
  if (lastTokenKind == TokenKind.ALL) {
    return new UriResourceLambdaAllImpl(lambbdaVariable, lambdaPredicateExpr);
  } else if (lastTokenKind == TokenKind.ANY) {
    return new UriResourceLambdaAnyImpl(lambbdaVariable, lambdaPredicateExpr);
  } else {
    throw new UriParserSyntaxException("Unexpected token.", UriParserSyntaxException.MessageKeys.SYNTAX);
  }
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
private void checkEqualityTypes(final Expression left, final Expression right) throws UriParserException {
  checkNoCollection(left);
  checkNoCollection(right);

  final EdmType leftType = getType(left);
  final EdmType rightType = getType(right);
  if (leftType == null || rightType == null || leftType.equals(rightType)) {
    return;
  }

  // Numeric promotion for Edm.Byte and Edm.SByte
  if (isType(leftType, EdmPrimitiveTypeKind.Byte, EdmPrimitiveTypeKind.SByte)
      && isType(rightType, EdmPrimitiveTypeKind.Byte, EdmPrimitiveTypeKind.SByte)) {
    return;
  }

  if (leftType.getKind() != EdmTypeKind.PRIMITIVE
      || rightType.getKind() != EdmTypeKind.PRIMITIVE
      || !(((EdmPrimitiveType) leftType).isCompatible((EdmPrimitiveType) rightType)
      || ((EdmPrimitiveType) rightType).isCompatible((EdmPrimitiveType) leftType))) {
    throw new UriParserSemanticException("Incompatible types.",
        UriParserSemanticException.MessageKeys.TYPES_NOT_COMPATIBLE,
        leftType.getFullQualifiedName().getFullQualifiedNameAsString(),
        rightType.getFullQualifiedName().getFullQualifiedNameAsString());
  }
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
private Compute parseComputeTrafo(EdmStructuredType referencedType)
    throws UriParserException, UriValidationException {
  ComputeImpl compute = new ComputeImpl();
  do {
    final Expression expression = new ExpressionParser(edm, odata)
        .parse(tokenizer, referencedType, crossjoinEntitySetNames, aliases);
    final EdmType expressionType = ExpressionParser.getType(expression);
    if (expressionType.getKind() != EdmTypeKind.PRIMITIVE) {
      throw new UriParserSemanticException("Compute expressions must return primitive values.",
          UriParserSemanticException.MessageKeys.ONLY_FOR_PRIMITIVE_TYPES, "compute");
    }
    final String alias = parseAsAlias(referencedType, true);
    ((DynamicStructuredType) referencedType).addProperty(createDynamicProperty(alias, expressionType));
    compute.addExpression(new ComputeExpressionImpl()
        .setExpression(expression)
        .setAlias(alias));
  } while (tokenizer.next(TokenKind.COMMA));
  ParserHelper.requireNext(tokenizer, TokenKind.CLOSE);
  return compute;
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
public OrderByOption parse(UriTokenizer tokenizer, final EdmStructuredType referencedType,
    final Collection<String> crossjoinEntitySetNames, final Map<String, AliasQueryOption> aliases)
    throws UriParserException, UriValidationException {
  OrderByOptionImpl orderByOption = new OrderByOptionImpl();
  do {
    final Expression orderByExpression = new ExpressionParser(edm, odata)
        .parse(tokenizer, referencedType, crossjoinEntitySetNames, aliases);
    OrderByItemImpl item = new OrderByItemImpl();
    item.setExpression(orderByExpression);
    if (tokenizer.next(TokenKind.AscSuffix)) {
      item.setDescending(false);
    } else if (tokenizer.next(TokenKind.DescSuffix)) {
      item.setDescending(true);
    }
    orderByOption.addOrder(item);
  } while (tokenizer.next(TokenKind.COMMA));
  return orderByOption;
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
@Test
public void relational() throws Exception {
  Expression expression = parseExpression("5 gt 5");
  assertEquals("{5 GT 5}", expression.toString());

  expression = parseExpression("5 ge 5");
  assertEquals("{5 GE 5}", expression.toString());

  expression = parseExpression("5 lt 5");
  assertEquals("{5 LT 5}", expression.toString());

  expression = parseExpression("5 le 5");
  assertEquals("{5 LE 5}", expression.toString());

  assertEquals("{5 LE 5.1}", parseExpression("5 le 5.1").toString());

  assertEquals("{1 GT null}", parseExpression("1 gt null").toString());
  assertEquals("{null GE 2}", parseExpression("null ge 2").toString());
  assertEquals("{null LE null}", parseExpression("null le null").toString());

  wrongExpression("5 gt duration'PT5H'");
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
private void parseMethod(TokenKind kind, String... parameters) throws UriParserException, UriValidationException {
  final String methodName = kind.name().substring(0, kind.name().indexOf("Method")).toLowerCase(Locale.ROOT)
      .replace("geo", "geo.");
  String expressionString = methodName + '(';
  boolean first = true;
  for (final String parameter : parameters) {
    if (first) {
      first = false;
    } else {
      expressionString += ',';
    }
    expressionString += parameter;
  }
  expressionString += ')';

  final Expression expression = parseExpression(expressionString);
  assertEquals('{' + methodName + ' ' + Arrays.toString(parameters) + '}',
      expression.toString());
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
@Override
public Object visitLambdaExpression(
    String lambdaFunction,
    String lambdaVariable,
    Expression expression) throws ExpressionVisitException, ODataApplicationException {

  throw new NotImplementedException("visitLambdaExpression not implemented");
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
private SparqlExpressionVisitor filterClause(FilterOption filter, RdfEntityType entityType, String nextTargetKey)
		throws ODataApplicationException, ExpressionVisitException {
	SparqlExpressionVisitor sparqlExpressionVisitor = new SparqlExpressionVisitor(rdfModel, rdfModelToMetadata,
			entityType, nextTargetKey);
	if (filter != null) {
		Expression filterExpression = filter.getExpression();
		final Object visitorResult;
		final String result;
		visitorResult = filterExpression.accept(sparqlExpressionVisitor);
		result = new String((String) visitorResult);
		sparqlExpressionVisitor.setConditionString(result);
	}
	return sparqlExpressionVisitor;
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
@Override
public ExpressionMember visitLambdaExpression(String lambdaFunction, String lambdaVariable,
        Expression expression) throws ExpressionVisitException, ODataApplicationException {
    // this method isn't used, because lambdas are handled by visitMember
    // method.
    return null;
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
/**
 * Analyzes uri parts and creates a member. Lambda has expression that
 * should be executed to get the inner query.
 *
 * @return nested or child expression member
 */
private ExpressionMember handleLambdaAny()
        throws ODataApplicationException, ExpressionVisitException {
    UriResourceLambdaAny lambda = (UriResourceLambdaAny) lastPart;
    Expression expression = lambda.getExpression();

    boolean isNavigationLambdaVar = firstPart instanceof UriResourcePartTyped
            && ((UriResourcePartTyped) firstPart).getType() instanceof EdmEntityType;
    if (firstPart instanceof UriResourceNavigation || isNavigationLambdaVar) {
        boolean isParentNestedLambdaVar = resourceParts.stream()
                .anyMatch(part -> part instanceof UriResourceComplexProperty);
        List<String> navigationTypes = collectNavigationTypes();
        if (isParentNestedLambdaVar) {
            // navigation parent nested collection
            // book?$filter=author/_dimension/any(d:d/name eq 'Validity')
            ExpressionResult lambdaResult = handleLambdaAny(expression);
            return new ParentWrapperMember(navigationTypes, lambdaResult.getQueryBuilder())
                    .any();
        } else {
            if (resourceParts.size() > 2) {
                // navigation parent to another child
                // book?$filter=author/address/any(a:a/city eq 'New York'))
                List<String> parentTypes = navigationTypes.subList(0,
                        navigationTypes.size() - 1);
                return new ParentWrapperMember(parentTypes,
                        handleChildLambda(lambda).getQueryBuilder()).any();
            } else {
                // navigation child property collection
                // author?$filter=book/any(b:b/character/any(c:c/name eq
                // 'Oliver'))
                return handleChildLambda(lambda);
            }
        }
    } else {
        // complex or primitive type collection
        return handleLambdaAny(expression);
    }
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
private void setPath(Expression expression) {
    if (expression instanceof Member) {
        setPath((Member) expression);
    } else if (expression instanceof Binary) {
        Binary binaryExpression = (Binary) expression;
        setPath(binaryExpression.getLeftOperand());
        setPath(binaryExpression.getRightOperand());
    } else if (expression instanceof Method) {
        Method method = (Method) expression;
        method.getParameters().forEach(this::setPath);
    }
}
 

import org.apache.olingo.server.api.uri.queryoption.expression.Expression; //导入依赖的package包/类
/**
 * Get's and creates metrics aggregation queries from {@link Aggregate} in
 * URL.
 * 
 * @param aggregations
 *            list of aggregations
 * @return list of queries
 * @throws ODataApplicationException
 *             if any error occurred
 */
protected List<AggregationBuilder> getMetricsAggQueries(List<Aggregate> aggregations)
        throws ODataApplicationException {
    List<AggregateExpression> expressions = aggregations.stream()
            .flatMap(agg -> agg.getExpressions().stream()).collect(Collectors.toList());
    List<AggregationBuilder> aggs = new ArrayList<>();
    for (AggregateExpression aggExpression : expressions) {
        try {
            if (aggExpression.getInlineAggregateExpression() != null) {
                throwNotImplemented(
                        "Aggregate for navigation or complex type fields is not supported.");
            }
            String alias = aggExpression.getAlias();
            Expression expr = aggExpression.getExpression();
            if (expr != null) {
                String field = ((PrimitiveMember) expr.accept(getExpressionVisitor()))
                        .getField();
                aggs.add(getAggQuery(aggExpression.getStandardMethod(), alias, field));
                metricAliases.add(alias);
            } else {
                List<UriResource> path = aggExpression.getPath();
                if (path.size() > 1) {
                    throwNotImplemented(
                            "Aggregate for navigation or complex type fields is not supported.");
                }
                UriResource resource = path.get(0);
                if (resource.getKind() == UriResourceKind.count) {
                    countAlias = alias;
                }
            }
        } catch (ExpressionVisitException e) {
            throw new ODataRuntimeException(e);
        }
    }
    return aggs;
}