@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); }
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])); } }
/** * 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; } }
/** * @see DATAGRAPH-632 */ @Test public void testFindByNestedBaseAndREProperty() { Filter planetParam = new Filter("totalDestructionProbability", ComparisonOperator.EQUALS, "20"); planetParam.setNestedPropertyName("collision"); planetParam.setNestedEntityTypeLabel("Collision"); //Collision is an RE planetParam.setNestedRelationshipEntity(true); planetParam.setRelationshipType("COLLIDES"); //assume COLLIDES is the RE type planetParam.setRelationshipDirection("OUTGOING"); planetParam.setNestedRelationshipEntity(true); Filter moonParam = new Filter("name", ComparisonOperator.EQUALS, "Moon"); moonParam.setNestedPropertyName("moon"); moonParam.setNestedEntityTypeLabel("Moon"); moonParam.setRelationshipType("ORBITS"); moonParam.setRelationshipDirection("INCOMING"); moonParam.setBooleanOperator(BooleanOperator.AND); assertThat(queryStatements.findByType("Asteroid", new Filters().add(planetParam, moonParam), 1).getStatement()) .isEqualTo("MATCH (n:`Asteroid`) MATCH (n)-[r0:`COLLIDES`]->(m0) " + "WHERE r0.`totalDestructionProbability` = { `collision_totalDestructionProbability_0` } " + "MATCH (m1:`Moon`) WHERE m1.`name` = { `moon_name_1` } MATCH (n)<-[:`ORBITS`]-(m1) WITH DISTINCT n MATCH p=(n)-[*0..1]-(m) RETURN p, ID(n)"); }
public Collection<NewsSource> findSourcesWithoutLogo() { Filter nullLogoFilter = new Filter("logoUrl", ComparisonOperator.IS_NULL); Filter emptyLogoFilter = new Filter("logoUrl", ComparisonOperator.EQUALS, ""); emptyLogoFilter.setBooleanOperator(BooleanOperator.OR); Filters filters = new Filters(nullLogoFilter, emptyLogoFilter); return getSession().loadAll(NewsSource.class, filters); }
/** * @see DATAGRAPH-445 */ @Test public void testFindByChainedOredProperties() { Filter planetParam = new Filter("name", ComparisonOperator.EQUALS, "Earth"); Filter moonParam = new Filter("name", ComparisonOperator.EQUALS, "Moon"); assertThat(queryStatements.findByType("Asteroid", new Filters().add(planetParam).or(moonParam), 1).getStatement()) .isEqualTo("MATCH (n:`Asteroid`) WHERE n.`name` = { `name_0` } " + "OR n.`name` = { `name_1` } WITH n MATCH p=(n)-[*0..1]-(m) RETURN p, ID(n)"); }
@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` } "); }
@Test public void loadFilmByRating() { Filter filter = new Filter("stars", ComparisonOperator.EQUALS, 5); filter.setOwnerEntityType(Movie.class); filter.setNestedPath( new Filter.NestedPathSegment("ratings", Rating.class) ); Collection<Movie> films = session.loadAll(Movie.class, filter); assertThat(films).hasSize(1); }
void resolvePropertyAnnotations(Class entityType, Iterable<Filter> filters) { for (Filter filter : filters) { if (filter.getOwnerEntityType() == null) { filter.setOwnerEntityType(entityType); String propertyName = resolvePropertyName(filter.getOwnerEntityType(), filter.getPropertyName()); Filter.setNameFromProperty(filter, propertyName); FieldInfo fieldInfo = classInfo.getFieldInfo(filter.getPropertyName()); if (fieldInfo != null) { filter.setPropertyConverter(fieldInfo.getPropertyConverter()); filter.setCompositeConverter(fieldInfo.getCompositeConverter()); if (filter.isNested()) { resolveRelationshipType(filter); ClassInfo nestedClassInfo = session.metaData().classInfo(filter.getNestedPropertyType().getName()); filter.setNestedEntityTypeLabel(session.metaData().entityType(nestedClassInfo.name())); if (session.metaData().isRelationshipEntity(nestedClassInfo.name())) { filter.setNestedRelationshipEntity(true); } else if (filter.isDeepNested()) { Class parentOwnerType = filter.getOwnerEntityType(); for (Filter.NestedPathSegment nestedPathSegment : filter.getNestedPath()) { resolveRelationshipType(parentOwnerType, nestedPathSegment); ClassInfo nestedClassInfo = session.metaData().classInfo(nestedPathSegment.getPropertyType().getName());
@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} ) "); }
@Override public Collection<FlowSegment> findByFlowIdAndCookie(String flowId, long flowCookie) { Filter flowIdFilter = new Filter(FLOW_ID_PROPERTY_NAME, ComparisonOperator.EQUALS, flowId); Filter cookieFilter = new Filter(COOKIE_PROPERTY_NAME, ComparisonOperator.EQUALS, flowCookie); return getSession().loadAll(getEntityType(), flowIdFilter.and(cookieFilter), DEPTH_LOAD_ENTITY); }
@Test public void loadFilmByUserAndRatingUserPlays() { Filter userFilter = new Filter("name", ComparisonOperator.EQUALS, "Michal"); userFilter.setNestedPath( new Filter.NestedPathSegment("ratings", Rating.class), new Filter.NestedPathSegment("user", User.class) ); Filter playsFilter = new Filter("level", ComparisonOperator.EQUALS, "ok"); playsFilter.setOwnerEntityType(Movie.class); playsFilter.setNestedPath( new Filter.NestedPathSegment("ratings", Rating.class), new Filter.NestedPathSegment("user", User.class), new Filter.NestedPathSegment("plays", Plays.class) ); Filters filters = userFilter.and(playsFilter); Collection<Movie> films = session.loadAll(Movie.class, filters); assertThat(films).hasSize(2); }
Filter createSrcSwitchFilter(SwitchId switchId) { Filter srcSwitchFilter = new Filter(SWITCH_NAME_PROPERTY_NAME, ComparisonOperator.EQUALS, switchId.toString()); srcSwitchFilter.setNestedPath(new Filter.NestedPathSegment(SRC_SWITCH_FIELD, Switch.class)); return srcSwitchFilter; }
@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` }) "); }
if (filter.isNested() || filter.isDeepNested()) { if (filter.getBooleanOperator().equals(BooleanOperator.OR)) { throw new UnsupportedOperationException( "OR is not supported for nested properties on a relationship entity"); String startNestedEntityTypeLabel = filter.getNestedEntityTypeLabel(); String endNestedEntityTypeLabel = filter.getNestedEntityTypeLabel(); String relationshipDirection = filter.getRelationshipDirection(); if (filter.isDeepNested()) { List<Filter.NestedPathSegment> nestedPath = filter.getNestedPath(); Filter.NestedPathSegment firstNestedPathSegment = nestedPath.get(0); Filter.NestedPathSegment lastNestedPathSegment = nestedPath.get(nestedPath.size() - 1); if (filter.getBooleanOperator().equals(BooleanOperator.NONE)) { if (noneOperatorEncounteredInStartFilters) { throw new MissingOperatorException( "BooleanOperator missing for filter with property name " + filter.getPropertyName()); filter.setBooleanOperator(BooleanOperator.NONE); //the first filter for the start node if (filter.getBooleanOperator().equals(BooleanOperator.NONE)) { if (noneOperatorEncounteredInEndFilters) { throw new MissingOperatorException( "BooleanOperator missing for filter with property name " + filter.getPropertyName()); filter.setBooleanOperator(BooleanOperator.NONE); //the first filter for the end node filter.setBooleanOperator(
@Test public void loadRatingByUserName() { Filter userNameFilter = new Filter("name", ComparisonOperator.EQUALS, "Michal"); Filter ratingFilter = new Filter("stars", ComparisonOperator.EQUALS, 5); userNameFilter.setNestedPath( new Filter.NestedPathSegment("user", User.class) ); Collection<Rating> ratings = session.loadAll(Rating.class, userNameFilter.and(ratingFilter)); assertThat(ratings).hasSize(1); } @Test
@Test public void joinFiltersWithAndMethod() { Filter filter1 = new Filter("property1", ComparisonOperator.EQUALS, "value1"); Filter filter2 = new Filter("property2", ComparisonOperator.EQUALS, "value2"); Filters andFilter = filter1.and(filter2); assertThat(filter2.getBooleanOperator()).isEqualTo(BooleanOperator.AND); Iterator<Filter> iterator = andFilter.iterator(); assertThat(iterator.next()).isEqualTo(filter1); assertThat(iterator.next()).isEqualTo(filter2); }
@Test public void inCollectionFilterTest() { ContainsAnyComparison filterFunction = new ContainsAnyComparison("test"); Filter filter = new Filter("property", filterFunction); assertThat(filter.toCypher("n", true)) .isEqualTo("WHERE ANY(collectionFields IN {`property_0`} WHERE collectionFields in n.`property`) "); assertThat(filter.parameters().get("property_0")).isEqualTo("test"); }
@Test public void joinFiltersWithOrMethod() { Filter filter1 = new Filter("property1", ComparisonOperator.EQUALS, "value1"); Filter filter2 = new Filter("property2", ComparisonOperator.EQUALS, "value2"); Filters andFilter = filter1.or(filter2); assertThat(filter2.getBooleanOperator()).isEqualTo(BooleanOperator.OR); Iterator<Filter> iterator = andFilter.iterator(); assertThat(iterator.next()).isEqualTo(filter1); assertThat(iterator.next()).isEqualTo(filter2); }