QueryRendererDelegateImpl(String queryString, ObjectPropertyHelper<TypeMetadata> propertyHelper) { this.queryString = queryString; this.propertyHelper = propertyHelper; this.whereBuilder = new ExpressionBuilder<>(propertyHelper); this.havingBuilder = new ExpressionBuilder<>(propertyHelper); }
@Override public void predicateConstantBoolean(boolean booleanConstant) { if (phase == Phase.WHERE) { whereBuilder.addConstantBoolean(booleanConstant); } else if (phase == Phase.HAVING) { havingBuilder.addConstantBoolean(booleanConstant); } 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(); } }
@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(); } }
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(); } }
@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 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 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 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 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(); } }