@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) { 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); }
@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); }
@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 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; }
/** * 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 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) { 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) { 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); }
@Test public void toCypher() { Filter filter = new Filter("moons", ComparisonOperator.LESS_THAN, 23); filter.setBooleanOperator(BooleanOperator.AND); assertThat(filter.toCypher("n", true)).isEqualTo("WHERE n.`moons` < { `moons_0` } "); }
@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); }
@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); }
@Test public void ignoreCaseShouldNotBeApplicableToComparisonOtherThanEquals() { expectedException.expect(IllegalStateException.class); expectedException.expectMessage("ignoreCase is only supported for EQUALS comparison"); Filter filter = new Filter("thing", ComparisonOperator.IS_NULL); filter.setBooleanOperator(BooleanOperator.AND); assertThat(filter.toCypher("n", true)).isEqualTo("WHERE n.`thing` IS NULL "); filter.ignoreCase(); assertThat(filter.toCypher("n", true)).isEqualTo("WHERE n.`thing` IS NULL "); } }
@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} ) "); }
/** * @see DATAGRAPH-629 */ @Test public void testFindByMultipleAndPropertiesGreaterThanWithDifferentOrder() { Filter nameParam = new Filter("name", ComparisonOperator.EQUALS, "AST-1"); nameParam.setBooleanOperator(BooleanOperator.AND); Filter diameterParam = new Filter("diameter", ComparisonOperator.GREATER_THAN, 60); assertThat( queryStatements.findByType("Asteroid", new Filters().add(diameterParam).add(nameParam), 2).getStatement()) .isEqualTo( "MATCH (n:`Asteroid`) WHERE n.`diameter` > { `diameter_0` } AND n.`name` = { `name_1` } WITH n MATCH p=(n)-[*0..2]-(m) RETURN p, ID(n)"); }
/** * @see DATAGRAPH-629 */ @Test public void testFindByMultipleOrPropertiesGreaterThanWithDifferentOrder() { Filter nameParam = new Filter("name", ComparisonOperator.EQUALS, "AST-1"); nameParam.setBooleanOperator(BooleanOperator.OR); Filter diameterParam = new Filter("diameter", ComparisonOperator.GREATER_THAN, 60); assertThat( queryStatements.findByType("Asteroid", new Filters().add(diameterParam).add(nameParam), 2).getStatement()) .isEqualTo( "MATCH (n:`Asteroid`) WHERE n.`diameter` > { `diameter_0` } OR n.`name` = { `name_1` } WITH n MATCH p=(n)-[*0..2]-(m) RETURN p, ID(n)"); }