Java FilterOption类代码示例

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
private void applyOptionsToEntityCollection(final EntityCollection entitySet,
    final EdmBindingTarget edmBindingTarget,
    final FilterOption filterOption, final OrderByOption orderByOption, final CountOption countOption,
    final SkipOption skipOption, final TopOption topOption, final ExpandOption expandOption,
    final UriInfoResource uriInfo, final Edm edm)
    throws ODataApplicationException {

  FilterHandler.applyFilterSystemQuery(filterOption, entitySet, uriInfo, edm);
  OrderByHandler.applyOrderByOption(orderByOption, entitySet, uriInfo, edm);
  CountHandler.applyCountSystemQueryOption(countOption, entitySet);
  SkipHandler.applySkipSystemQueryHandler(skipOption, entitySet);
  TopHandler.applyTopSystemQueryOption(topOption, entitySet);

  // Apply nested expand system query options to remaining entities
  if (expandOption != null) {
    for (final Entity entity : entitySet.getEntities()) {
      applyExpandOptionToEntity(entity, edmBindingTarget, expandOption, uriInfo, edm);
    }
  }
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
/**
 * This method applies filter query option to the given entity collection.
 *
 * @param filterOption Filter option
 * @param entitySet    Entity collection
 * @param edmEntitySet Entity set
 * @throws ODataApplicationException
 */
public static void applyFilterSystemQuery(final FilterOption filterOption, final EntityCollection entitySet,
                                          final EdmBindingTarget edmEntitySet) throws ODataApplicationException {
    try {
        final Iterator<Entity> iter = entitySet.getEntities().iterator();
        while (iter.hasNext()) {
            final VisitorOperand operand =
                    filterOption.getExpression().accept(new ExpressionVisitorImpl(iter.next(), edmEntitySet));
            final TypedOperand typedOperand = operand.asTypedOperand();

            if (typedOperand.is(ODataConstants.primitiveBoolean)) {
                if (Boolean.FALSE.equals(typedOperand.getTypedValue(Boolean.class))) {
                    iter.remove();
                }
            } else {
                throw new ODataApplicationException(
                        "Invalid filter expression. Filter expressions must return a value of " +
                        "type Edm.Boolean", HttpStatusCode.BAD_REQUEST.getStatusCode(), Locale.ROOT);
            }
        }

    } catch (ExpressionVisitException e) {
        throw new ODataApplicationException("Exception in filter evaluation",
                                            HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), Locale.ROOT);
    }
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
private static QueryBuilder toQueryBuilder(FilterOption filterOption)
    throws ODataApplicationException {

  if (filterOption == null) {
    return QueryBuilders.matchAllQuery();
  }

  try {
    return (QueryBuilder) filterOption.getExpression()
        .accept(new ElasticsearchExpressionVisitor());
  } catch (ExpressionVisitException e) {
    throw new ODataApplicationException(
        "accept failed", HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), null, e);
  }
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的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.FilterOption; //导入依赖的package包/类
public static void applyFilterSystemQuery(final FilterOption filterOption, final EntityCollection entitySet,
    final UriInfoResource uriInfo, final Edm edm) throws ODataApplicationException {

  if (filterOption == null) {
    return;
  }

  try {
    final Iterator<Entity> iter = entitySet.getEntities().iterator();

    while (iter.hasNext()) {
      final VisitorOperand operand = filterOption.getExpression()
          .accept(new ExpressionVisitorImpl(iter.next(), uriInfo, edm));
      final TypedOperand typedOperand = operand.asTypedOperand();

      if (typedOperand.is(primBoolean)) {
        if (Boolean.FALSE.equals(typedOperand.getTypedValue(Boolean.class))) {
          iter.remove();
        }
      } else {
        throw new ODataApplicationException(
            "Invalid filter expression. Filter expressions must return a value of type Edm.Boolean",
            HttpStatusCode.BAD_REQUEST.getStatusCode(), Locale.ROOT);
      }
    }

  } catch (ExpressionVisitException e) {
    throw new ODataApplicationException("Exception in filter evaluation",
        HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), Locale.ROOT);
  }
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
public FilterOption parse(UriTokenizer tokenizer, final EdmType referencedType,
    final Collection<String> crossjoinEntitySetNames, final Map<String, AliasQueryOption> aliases)
    throws UriParserException, UriValidationException {
  final Expression filterExpression = new ExpressionParser(edm, odata)
      .parse(tokenizer, referencedType, crossjoinEntitySetNames, aliases);
  final EdmType type = ExpressionParser.getType(filterExpression);
  if (type == null || type.equals(odata.createPrimitiveTypeInstance(EdmPrimitiveTypeKind.Boolean))) {
    return new FilterOptionImpl().setExpression(filterExpression);
  } else {
    throw new UriParserSemanticException("Filter expressions must be boolean.",
        UriParserSemanticException.MessageKeys.TYPES_NOT_COMPATIBLE,
        "Edm.Boolean", type.getFullQualifiedName().getFullQualifiedNameAsString());
  }
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
private void parseFilterOption(FilterOption filterOption, final EdmType contextType,
    final List<String> entitySetNames, final Map<String, AliasQueryOption> aliases)
    throws UriParserException, UriValidationException {
  if (filterOption != null) {
    final String optionValue = filterOption.getText();
    UriTokenizer filterTokenizer = new UriTokenizer(optionValue);
    // The referring type could be a primitive type or a structured type.
    ((FilterOptionImpl) filterOption).setExpression(
        new FilterParser(edm, odata).parse(filterTokenizer, contextType, entitySetNames, aliases)
            .getExpression());
    checkOptionEOF(filterTokenizer, filterOption.getName(), optionValue);
  }
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
private List<Entity> applyFilterQueryOption(List<Entity> entityList, FilterOption filterOption)
    throws ODataApplicationException {

  if (filterOption != null) {
    try {
      Iterator<Entity> entityIterator = entityList.iterator();

      // Evaluate the expression for each entity
      // If the expression is evaluated to "true", keep the entity otherwise remove it from the entityList
      while (entityIterator.hasNext()) {
        // To evaluate the the expression, create an instance of the Filter Expression Visitor and pass
        // the current entity to the constructor
        Entity currentEntity = entityIterator.next();
        Expression filterExpression = filterOption.getExpression();
        FilterExpressionVisitor expressionVisitor = new FilterExpressionVisitor(currentEntity);

        // Start evaluating the expression
        Object visitorResult = filterExpression.accept(expressionVisitor);

        // The result of the filter expression must be of type Edm.Boolean
        if (visitorResult instanceof Boolean) {
          if (!Boolean.TRUE.equals(visitorResult)) {
            // The expression evaluated to false (or null), so we have to remove the currentEntity from entityList
            entityIterator.remove();
          }
        } else {
          throw new ODataApplicationException("A filter expression must evaulate to type Edm.Boolean",
              HttpStatusCode.BAD_REQUEST.getStatusCode(), Locale.ENGLISH);
        }
      }

    } catch (ExpressionVisitException e) {
      throw new ODataApplicationException("Exception in filter evaluation",
          HttpStatusCode.INTERNAL_SERVER_ERROR.getStatusCode(), Locale.ENGLISH);
    }
  }
  
  return entityList;
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
public void appendFilter(String alias,FilterOption filterOption) throws ODataApplicationException {
	if(filterOption != null) {
		try {
			appendFilter(alias,filterOption.getExpression());
		} catch (ExpressionVisitException e) {
			throw internalError(e);
		}
	}
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
@Override
public void visit(FilterOption info) {
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
@Override
public void visit(FilterOption info) {
	ODataExpressionToSQLVisitor visitor = new ODataExpressionToSQLVisitor(this, this.prepared, getUriInfo());
	this.criteria = (Criteria)visitor.getExpression(info.getExpression());
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
public static String Serialize(final FilterOption filter)
    throws ExpressionVisitException, ODataApplicationException {

  Expression expression = filter.getExpression();
  return expression.accept(new FilterTreeToText());
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
public FilterValidator setFilter(final FilterOption filter) {
  this.filter = filter;
  assertNotNull("FilterValidator: no filter found", filter.getExpression());
  setExpression(filter.getExpression());
  return this;
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
public FilterValidator goFilter() {
  final FilterOption filter = uriInfo.getFilterOption();
  assertNotNull("no filter found", filter);
  return new FilterValidator().setValidator(this).setFilter(filter);
}
 

import org.apache.olingo.server.api.uri.queryoption.FilterOption; //导入依赖的package包/类
private void appendCommonJsonObjects(JsonGenerator gen,
    final CountOption countOption, final SkipOption skipOption, final TopOption topOption,
    final FilterOption filterOption, final OrderByOption orderByOption,
    final SelectOption selectOption, final ExpandOption expandOption, final SearchOption searchOption,
    final ApplyOption applyOption)
    throws IOException {
  if (countOption != null) {
    gen.writeBooleanField("isCount", countOption.getValue());
  }

  if (skipOption != null) {
    gen.writeNumberField("skip", skipOption.getValue());
  }

  if (topOption != null) {
    gen.writeNumberField("top", topOption.getValue());
  }

  if (filterOption != null) {
    gen.writeFieldName("filter");
    appendExpressionJson(gen, filterOption.getExpression());
  }

  if (orderByOption != null && !orderByOption.getOrders().isEmpty()) {
    gen.writeFieldName("orderby");
    gen.writeStartObject();
    gen.writeStringField("nodeType", "orderCollection");
    gen.writeFieldName("orders");
    appendOrderByItemsJson(gen, orderByOption.getOrders());
    gen.writeEndObject();
  }

  if (selectOption != null && !selectOption.getSelectItems().isEmpty()) {
    gen.writeFieldName("select");
    appendSelectedPropertiesJson(gen, selectOption.getSelectItems());
  }

  if (expandOption != null && !expandOption.getExpandItems().isEmpty()) {
    gen.writeFieldName("expand");
    appendExpandedPropertiesJson(gen, expandOption.getExpandItems());
  }

  if (searchOption != null) {
    gen.writeFieldName("search");
    appendSearchJson(gen, searchOption.getSearchExpression());
  }

  if (applyOption != null) {
    gen.writeFieldName("apply");
    appendApplyItemsJson(gen, applyOption.getApplyItems());
  }
}