@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) { 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_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) { 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; }
@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_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) { 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) { 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); } }
@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} ) "); }
filter.setOwnerEntityType(entityType); filter.setBooleanOperator(booleanOperator); filter.setNegated(isNegated()); setNestedAttributes(part, filter);
@Test public void testFindByPropertyIsNull() { Filter isNull = new Filter("score", ComparisonOperator.IS_NULL, null); String statement = queryStatements.findByType("Restaurant", new Filters().add(isNull), 3).getStatement(); assertThat(statement) .isEqualTo("MATCH (n:`Restaurant`) WHERE n.`score` IS NULL WITH n MATCH p=(n)-[*0..3]-(m) RETURN p, ID(n)"); Filter isNotNull = new Filter("score", ComparisonOperator.IS_NULL, null); isNotNull.setNegated(true); statement = queryStatements.findByType("Restaurant", new Filters().add(isNotNull), 3).getStatement(); assertThat(statement).isEqualTo( "MATCH (n:`Restaurant`) WHERE NOT(n.`score` IS NULL ) WITH n MATCH p=(n)-[*0..3]-(m) RETURN p, ID(n)"); }
/** * @see DATAGRAPH-904 */ @Test public void shouldFilterByPropertyIsTrue() { Restaurant kazan = new Restaurant("Kazan", 77.0); kazan.setHalal(true); session.save(kazan); Restaurant kuroda = new Restaurant("Kuroda", 72.4); kuroda.setHalal(false); session.save(kuroda); Filter isHalal = new Filter("halal", ComparisonOperator.IS_TRUE); Collection<Restaurant> results = session.loadAll(Restaurant.class, new Filters().add(isHalal)); assertThat(results).isNotNull(); assertThat(results).hasSize(1); assertThat(results.iterator().next().getName()).isEqualTo("Kazan"); Filter notHalal = new Filter("halal", ComparisonOperator.IS_TRUE); notHalal.setNegated(true); results = session.loadAll(Restaurant.class, new Filters().add(notHalal)); assertThat(results).isNotNull(); assertThat(results).hasSize(1); assertThat(results.iterator().next().getName()).isEqualTo("Kuroda"); } }
/** * @see DATAGRAPH-904 */ @Test public void shouldFilterByIsNullOrNotNull() { Restaurant kuroda = new Restaurant("Kuroda", "Mainly Ramen"); session.save(kuroda); Restaurant cyma = new Restaurant(); cyma.setName("Cyma"); session.save(cyma); session.clear(); Filter descriptionIsNull = new Filter("description", ComparisonOperator.IS_NULL, null); Collection<Restaurant> results = session.loadAll(Restaurant.class, new Filters().add(descriptionIsNull)); assertThat(results).hasSize(1); Restaurant restaurant = results.iterator().next(); assertThat(restaurant.getName()).isEqualTo("Cyma"); Filter descriptionIsNotNull = new Filter("description", ComparisonOperator.IS_NULL, null); descriptionIsNotNull.setNegated(true); results = session.loadAll(Restaurant.class, new Filters().add(descriptionIsNotNull)); assertThat(results).hasSize(1); restaurant = results.iterator().next(); assertThat(restaurant.getName()).isEqualTo("Kuroda"); }
/** * @see DATAGRAPH-904 */ @Test public void shouldFilterByPropertyExists() { Restaurant sfo = new Restaurant("San Francisco International Airport (SFO)", 72.4); sfo.setLaunchDate(new Date(1000)); session.save(sfo); Restaurant kuroda = new Restaurant("Kuroda", 80.5); kuroda.setLaunchDate(new Date(2000)); session.save(kuroda); Filter exists = new Filter("name", ComparisonOperator.EXISTS); Collection<Restaurant> results = session.loadAll(Restaurant.class, new Filters().add(exists)); assertThat(results).isNotNull(); assertThat(results).hasSize(2); Filter notExists = new Filter("name", ComparisonOperator.EXISTS); notExists.setNegated(true); results = session.loadAll(Restaurant.class, new Filters().add(notExists)); assertThat(results).isNotNull(); assertThat(results).isEmpty(); }