@Override public void predicateNotEquals(String value) { activateNOT(); addComparisonPredicate(value, ComparisonExpr.Type.EQUAL); deactivateBoolean(); }
/** * Add 'group by' criteria. * * @param collateName optional collation name */ @Override public void groupingValue(String collateName) { // collationName is ignored for now if (groupBy == null) { groupBy = new ArrayList<>(ARRAY_INITIAL_LENGTH); } groupBy.add(resolveAlias(propertyPath)); }
@Override public void predicateBetween(String lowerValue, String upperValue) { ensureLeftSideIsAPropertyPath(); Object lowerComparisonValue = parameterValue(lowerValue); Object upperComparisonValue = parameterValue(upperValue); PropertyPath<TypeDescriptor<TypeMetadata>> property = resolveAlias(propertyPath); if (property.isEmpty()) { throw log.getPredicatesOnEntityAliasNotAllowedException(propertyPath.asStringPath()); } checkAnalyzed(property, false); if (phase == Phase.WHERE) { whereBuilder.addRange(property, lowerComparisonValue, upperComparisonValue); } else if (phase == Phase.HAVING) { havingBuilder.addRange(property, lowerComparisonValue, upperComparisonValue); } else { throw new IllegalStateException(); } }
@Override public void predicateFullTextRange(boolean includeLower, String lower, String upper, boolean includeUpper) { ensureLeftSideIsAPropertyPath(); if (phase == Phase.WHERE) { PropertyPath<TypeDescriptor<TypeMetadata>> property = resolveAlias(propertyPath); if (property.isEmpty()) { throw log.getPredicatesOnEntityAliasNotAllowedException(propertyPath.asStringPath()); } Object from = lower != null ? parameterValue(lower) : null; Object to = upper != null ? parameterValue(upper) : null; checkIndexed(property); whereBuilder.addFullTextRange(property, includeLower, from, to, includeUpper); } else if (phase == Phase.HAVING) { throw log.getFullTextQueriesNotAllowedInHavingClauseException(); } else { throw new IllegalStateException(); } }
@Override public void predicateIsNull() { ensureLeftSideIsAPropertyPath(); PropertyPath<TypeDescriptor<TypeMetadata>> property = resolveAlias(propertyPath); if (property.isEmpty()) { throw log.getPredicatesOnEntityAliasNotAllowedException(propertyPath.asStringPath()); } checkAnalyzed(property, false); if (phase == Phase.WHERE) { whereBuilder.addIsNull(property); } else if (phase == Phase.HAVING) { havingBuilder.addIsNull(property); } else { throw new IllegalStateException(); } }
@Override public void predicateIn(List<String> list) { ensureLeftSideIsAPropertyPath(); List<Object> values = new ArrayList<>(list.size()); for (String string : list) { values.add(parameterValue(string)); } PropertyPath<TypeDescriptor<TypeMetadata>> property = resolveAlias(propertyPath); if (property.isEmpty()) { throw log.getPredicatesOnEntityAliasNotAllowedException(propertyPath.asStringPath()); } if (phase == Phase.WHERE) { whereBuilder.addIn(property, values); } else if (phase == Phase.HAVING) { havingBuilder.addIn(property, values); } else { throw new IllegalStateException(); } }
/** * Add field sort criteria. * * @param collateName optional collation name * @param isAscending sort direction */ @Override public void sortSpecification(String collateName, boolean isAscending) { // collationName is ignored for now PropertyPath<TypeDescriptor<TypeMetadata>> property = resolveAlias(propertyPath); checkAnalyzed(property, false); //todo [anistor] cannot sort on analyzed field? if (sortFields == null) { sortFields = new ArrayList<>(ARRAY_INITIAL_LENGTH); } sortFields.add(new IckleParsingResult.SortFieldImpl<>(property, isAscending)); }
public static <TypeMetadata> IckleParsingResult<TypeMetadata> parse(String queryString, ObjectPropertyHelper<TypeMetadata> propertyHelper) { QueryResolverDelegateImpl resolverDelegate = new QueryResolverDelegateImpl<>(propertyHelper); QueryRendererDelegateImpl<TypeMetadata> rendererDelegate = new QueryRendererDelegateImpl<>(queryString, propertyHelper); queryParser.parseQuery(queryString, resolverDelegate, rendererDelegate); return rendererDelegate.getResult(); } }
@Override public void predicateGreaterOrEqual(String value) { addComparisonPredicate(value, ComparisonExpr.Type.GREATER_OR_EQUAL); }
@Override public void predicateLike(String patternValue, Character escapeCharacter) { ensureLeftSideIsAPropertyPath(); Object pattern = parameterValue(patternValue); PropertyPath<TypeDescriptor<TypeMetadata>> property = resolveAlias(propertyPath); if (property.isEmpty()) { throw log.getPredicatesOnEntityAliasNotAllowedException(propertyPath.asStringPath()); } checkAnalyzed(property, false); if (phase == Phase.WHERE) { whereBuilder.addLike(property, pattern, escapeCharacter); } else if (phase == Phase.HAVING) { havingBuilder.addLike(property, pattern, escapeCharacter); } else { throw new IllegalStateException(); } }
@Override public void predicateFullTextRegexp(String term) { ensureLeftSideIsAPropertyPath(); PropertyPath<TypeDescriptor<TypeMetadata>> property = resolveAlias(propertyPath); if (property.isEmpty()) { throw log.getPredicatesOnEntityAliasNotAllowedException(propertyPath.asStringPath()); } if (phase == Phase.WHERE) { checkAnalyzed(property, true); whereBuilder.addFullTextRegexp(property, term); } else if (phase == Phase.HAVING) { throw log.getFullTextQueriesNotAllowedInHavingClauseException(); } else { throw new IllegalStateException(); } }
@Override public void predicateLessOrEqual(String value) { addComparisonPredicate(value, ComparisonExpr.Type.LESS_OR_EQUAL); }
private void addComparisonPredicate(String value, ComparisonExpr.Type comparisonType) { ensureLeftSideIsAPropertyPath(); PropertyPath<TypeDescriptor<TypeMetadata>> property = resolveAlias(propertyPath); if (property.isEmpty()) { throw log.getPredicatesOnEntityAliasNotAllowedException(propertyPath.asStringPath()); } Object comparisonValue = parameterValue(value); checkAnalyzed(property, false); if (phase == Phase.WHERE) { whereBuilder.addComparison(property, comparisonType, comparisonValue); } else if (phase == Phase.HAVING) { havingBuilder.addComparison(property, comparisonType, comparisonValue); } else { throw new IllegalStateException(); } }
/** * This implements the equality predicate; the comparison * predicate could be a constant, a subfunction or * some random type parameter. * The tree node has all details but with current tree rendering * it just passes it's text so we have to figure out the options again. */ @Override public void predicateEquals(String value) { addComparisonPredicate(value, ComparisonExpr.Type.EQUAL); }
nullMarker = null; } else { projection = resolveAlias(propertyPath); propertyType = propertyHelper.getPrimitivePropertyType(targetEntityMetadata, projection.asArrayPath()); nullMarker = fieldIndexingMetadata.getNullMarker(projection.asArrayPath());
@Override public void predicateFullTextTerm(String term, String fuzzyFlop) { ensureLeftSideIsAPropertyPath(); PropertyPath<TypeDescriptor<TypeMetadata>> property = resolveAlias(propertyPath); if (property.isEmpty()) { throw log.getPredicatesOnEntityAliasNotAllowedException(propertyPath.asStringPath()); } String comparisonValue = (String) parameterValue(term); if (phase == Phase.WHERE) { checkAnalyzed(property, true); whereBuilder.addFullTextTerm(property, comparisonValue, fuzzyFlop == null ? null : (fuzzyFlop.equals("~") ? 2 : Integer.parseInt(fuzzyFlop))); } else if (phase == Phase.HAVING) { throw log.getFullTextQueriesNotAllowedInHavingClauseException(); } else { throw new IllegalStateException(); } }
@Override public void predicateLess(String value) { addComparisonPredicate(value, ComparisonExpr.Type.LESS); }
@Override public void predicateGreater(String value) { addComparisonPredicate(value, ComparisonExpr.Type.GREATER); }