@Override public List<Filter> build(Stack<Object> params) { Filter filter = new Filter(propertyName(), ComparisonOperator.EXISTS); filter.setOwnerEntityType(entityType); filter.setBooleanOperator(booleanOperator); filter.setNegated(isNegated()); setNestedAttributes(part, filter); return Collections.singletonList(filter); }
@Override public List<Filter> build(Stack<Object> params) { final Object containingValue = params.pop(); Filter containingFilter = new Filter(propertyName(), ComparisonOperator.IN, containingValue); containingFilter.setOwnerEntityType(entityType); containingFilter.setBooleanOperator(booleanOperator); containingFilter.setNegated(isNegated()); containingFilter.setFunction(new ContainsAnyComparison(containingValue)); setNestedAttributes(part, containingFilter); return Collections.singletonList(containingFilter); }
@Override public List<Filter> build(Stack<Object> params) { final Object value1 = params.pop(); Filter gt = new Filter(propertyName(), ComparisonOperator.GREATER_THAN_EQUAL, value1); gt.setOwnerEntityType(entityType); gt.setBooleanOperator(booleanOperator); gt.setNegated(isNegated()); gt.setFunction(new PropertyComparison(value1)); setNestedAttributes(part, gt); final Object value2 = params.pop(); Filter lt = new Filter(propertyName(), ComparisonOperator.LESS_THAN_EQUAL, value2); lt.setOwnerEntityType(entityType); lt.setBooleanOperator(BooleanOperator.AND); lt.setNegated(isNegated()); lt.setFunction(new PropertyComparison(value2)); setNestedAttributes(part, lt); return Arrays.asList(gt, lt); } }
private Filter createFilterForSpringPoint(Distance distance, Point point, double meters) { DistanceFromPoint distanceFromPoint = new DistanceFromPoint(point.getX(), point.getY(), distance.getValue() * meters); DistanceComparison distanceComparison = new DistanceComparison(distanceFromPoint); Filter filter = new Filter(distanceComparison, ComparisonOperator.LESS_THAN); filter.setOwnerEntityType(entityType); filter.setBooleanOperator(booleanOperator); filter.setNegated(isNegated()); setNestedAttributes(part, filter); return filter; }
private Filter createFilterForSpatialPoint(AbstractPoint spatialPoint, double meters) { NativeDistanceComparison distanceComparison = NativeDistanceComparison .distanceComparisonFor(new DistanceFromNativePoint(spatialPoint, meters)); String propertyName = super.part.getProperty().getLeafProperty().getSegment(); Filter filter = new Filter(propertyName, distanceComparison, ComparisonOperator.LESS_THAN); filter.setOwnerEntityType(entityType); filter.setBooleanOperator(booleanOperator); filter.setNegated(isNegated()); setNestedAttributes(part, filter); return filter; }
protected void setNestedAttributes(Part part, Filter filter) { List<Filter.NestedPathSegment> segments = new ArrayList<>(); PropertyPath property = part.getProperty(); if (property.hasNext()) { filter.setOwnerEntityType(property.getOwningType().getType()); segments.add(new Filter.NestedPathSegment(property.getSegment(), property.getType())); segments.addAll(deepNestedProperty(property)); filter.setPropertyName(property.getLeafProperty().getSegment()); filter.setNestedPath(segments.toArray(new Filter.NestedPathSegment[0])); } }
/** * Convenience method to chain filters using {@link BooleanOperator#OR}. * * @param filter to be chained. * @return new {@link Filters} object containing both filters. */ public Filters or(Filter filter) { filter.setBooleanOperator(BooleanOperator.OR); return new Filters(this, filter); }
/** * Convenience method to add a filter using {@link BooleanOperator#OR}. * * @param filter to be chained. * @return current {@link Filters} object with chained {@link Filter}. */ public Filters or(Filter filter) { filter.setBooleanOperator(BooleanOperator.OR); return add(filter); }
Query createExecutableQuery(Map<Integer, Object> resolvedParameters) { // building a stack of parameter values, so that the builders can pull them // according to their needs (zero, one or more parameters) // avoids to manage a current parameter index state here. Stack<Object> parametersStack = new Stack<>(); if (!resolvedParameters.isEmpty()) { Integer maxParameterIndex = Collections.max(resolvedParameters.keySet()); for (int i = 0; i <= maxParameterIndex; i++) { parametersStack.add(0, resolvedParameters.get(i)); } } List<Filter> filters = new ArrayList<>(); for (FilterBuilder filterBuilder : filterBuilders) { filters.addAll(filterBuilder.build(parametersStack)); } return new Query(new Filters(filters)); } }
private Object transformPropertyValue(Object value) { if (this.comparisonOperator != null) { return this.comparisonOperator.getPropertyValueTransformer().transformPropertyValue(value); } return new NoOpPropertyValueTransformer().transformPropertyValue(value); }
@Override public String expression(final String nodeIdentifier) { final Filter filter = this.getFilter(); return String.format("toLower(%s.`%s`) %s toLower({ `%s` }) ", nodeIdentifier, filter.getPropertyName(), ComparisonOperator.EQUALS.getValue(), filter.uniqueParameterName()); } }
private List<Filter.NestedPathSegment> deepNestedProperty(PropertyPath path) { List<Filter.NestedPathSegment> segments = new ArrayList<>(); if (path.hasNext()) { PropertyPath next = path.next(); if (next != null && !next.equals(next.getLeafProperty())) { segments.add(new Filter.NestedPathSegment(next.getSegment(), next.getType())); segments.addAll(deepNestedProperty(next)); } } return segments; }
/** * Sets the filter to ignore the case in case the underlying {@link Part} requires ignoring case and the property * actually supports it. Note: The method is modelled after {@link #setNestedAttributes(Part, Filter)} to have some * consistency. Preferable it should return a new filter. * * @param part * @param filter */ private void applyCaseInsensitivityIfShouldIgnoreCase(Part part, Filter filter) { switch (part.shouldIgnoreCase()) { case ALWAYS: Assert.state(canIgnoreCase(part), "Unable to ignore case of " + part.getProperty().getLeafType().getName() + " types, the property '" + part.getProperty().getSegment() + "' must reference a String"); filter.ignoreCase(); break; case WHEN_POSSIBLE: if (canIgnoreCase(part)) { filter.ignoreCase(); } break; case NEVER: default: break; } }
/** * */ public boolean isOneOf(ComparisonOperator... these) { for (ComparisonOperator candidate : these) { if (this.equals(candidate)) { return true; } } return false; }
@Override public List<Filter> build(Stack<Object> params) { Filter filter = new Filter(propertyName(), ComparisonOperator.IS_TRUE); filter.setOwnerEntityType(entityType); filter.setBooleanOperator(booleanOperator); filter.setNegated(isNegated() || part.getType() == FALSE); setNestedAttributes(part, filter); return Collections.singletonList(filter); }
/** * Convenience method to chain filters using {@link BooleanOperator#AND}. * * @param filter to be chained * @return new {@link Filters} object containing both filters. */ public Filters and(Filter filter) { filter.setBooleanOperator(BooleanOperator.AND); return new Filters(this, filter); }
/** * Convenience method to add a filter using {@link BooleanOperator#AND}. * * @param filter to be chained. * @return current {@link Filters} object with chained {@link Filter}. */ public Filters and(Filter filter) { filter.setBooleanOperator(BooleanOperator.AND); return add(filter); }
@Override public List<Filter> build(Stack<Object> params) { Filter filter = new Filter(propertyName(), ComparisonOperator.IS_NULL); filter.setOwnerEntityType(entityType); filter.setBooleanOperator(booleanOperator); filter.setNegated(isNegated() || part.getType() == IS_NOT_NULL); setNestedAttributes(part, filter); return Collections.singletonList(filter); }
@Override public List<Filter> build(Stack<Object> params) { Object value = params.pop(); Filter filter = new Filter(propertyName(), convertToComparisonOperator(part.getType()), value); filter.setOwnerEntityType(entityType); filter.setBooleanOperator(booleanOperator); filter.setNegated(isNegated()); setNestedAttributes(part, filter); applyCaseInsensitivityIfShouldIgnoreCase(part, filter); return Collections.singletonList(filter); }