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; }
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; }
@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); }
public Filter(String propertyName, ComparisonOperator comparisonOperator, Object propertyValue) { this(propertyName, new PropertyComparison(propertyValue), comparisonOperator); }
@Override public Map<String, Object> parameters() { Map<String, Object> map = new HashMap<>(); map.put("lat", value.getLatitude()); map.put("lon", value.getLongitude()); map.put("distance", value.getDistance()); return map; } }
@Override public Map<String, Object> parameters() { Map<String, Object> map = new HashMap<>(); map.put(OGM_POINT_PARAMETER, distanceFromNativePoint.getPoint()); map.put(DISTANCE_VALUE_PARAMETER, distanceFromNativePoint.getDistance()); return map; } }
public Filter(String propertyName, FilterFunction filterFunction, ComparisonOperator comparisonOperator) { this.index = 0; this.propertyName = propertyName; this.function = filterFunction; this.function.setFilter(this); this.comparisonOperator = comparisonOperator; }
public Map<String, Object> parameters() { return function.parameters(); }
public static NativeDistanceComparison distanceComparisonFor(DistanceFromNativePoint distanceFromNativePoint) { return new NativeDistanceComparison(distanceFromNativePoint); }
@Override public String expression(String nodeIdentifier) { String pointPropertyOfEntity = nodeIdentifier + "." + getFilter().getPropertyName(); String comparisonOperator = getFilter().getComparisonOperator().getValue(); return String.format( "distance({%s},%s) %s {%s} ", OGM_POINT_PARAMETER, pointPropertyOfEntity, comparisonOperator, DISTANCE_VALUE_PARAMETER); }
/** * @param nodeIdentifier The node identifier * @param addWhereClause The add where clause. * @return The filter state as a CYPHER fragment. */ public String toCypher(String nodeIdentifier, boolean addWhereClause) { String fragment = this.function.expression(nodeIdentifier); String suffix = isNegated() ? negate(fragment) : fragment; return cypherPrefix(addWhereClause) + suffix; }
@Test public void toCypher_function() { DistanceComparison function = new DistanceComparison(new DistanceFromPoint(37.4, 112.1, 1000.0)); Filter filter = new Filter(function, ComparisonOperator.LESS_THAN); filter.setBooleanOperator(BooleanOperator.AND); filter.setNegated(true); assertThat(filter.toCypher("n", true)) .isEqualTo( "WHERE NOT(distance(point({latitude: n.latitude, longitude: n.longitude}),point({latitude:{lat}, longitude:{lon}})) < {distance} ) "); }
@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); } }
@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); }
public void setFunction(FilterFunction function) { assert function != null; this.function = function; this.function.setFilter(this); }
private static void appendFilters(List<Filter> filters, String nodeIdentifier, StringBuilder query, Map<String, Object> properties) { for (Filter filter : filters) { query.append(filter.toCypher(nodeIdentifier, false)); properties.putAll(filter.getFunction().parameters()); } } }
@Test public void testFindByDistance() { DistanceComparison function = new DistanceComparison(new DistanceFromPoint(37.4d, 112.9d, 1000.0d)); Filters filters = new Filters().add(new Filter(function, ComparisonOperator.EQUALS)); String statement = queryStatements.findByType("Restaurant", filters, 4).getStatement(); assertThat(statement).isEqualTo( "MATCH (n:`Restaurant`) WHERE distance(point({latitude: n.latitude, longitude: n.longitude}),point({latitude:{lat}, longitude:{lon}})) = {distance} WITH n MATCH p=(n)-[*0..4]-(m) RETURN p, ID(n)"); }
public Filter(String propertyName, ComparisonOperator comparisonOperator) { this(new PropertyComparison(null)); this.propertyName = propertyName; if (!EnumSet.of(ComparisonOperator.EXISTS, ComparisonOperator.IS_TRUE, ComparisonOperator.IS_NULL) .contains(comparisonOperator)) { throw new RuntimeException("This constructor can only be used with Unary comparison operators"); } this.comparisonOperator = comparisonOperator; }
@Test public void equalComparisionShouldWork() { final String value = "someOtherThing"; Filter filter = new Filter("thing", ComparisonOperator.EQUALS, value); filter.setFunction(new PropertyComparison(value)); assertThat(filter.toCypher("n", true)).isEqualTo("WHERE n.`thing` = { `thing_0` } "); filter = new Filter("thing", ComparisonOperator.EQUALS, value); filter.ignoreCase(); assertThat(filter.toCypher("n", true)).isEqualTo("WHERE toLower(n.`thing`) = toLower({ `thing_0` }) "); }