@Override public Collection<Isl> findByPartialEndpoints(SwitchId srcSwitchId, Integer srcPort, SwitchId dstSwitchId, Integer dstPort) { Filters filters = new Filters(); if (srcSwitchId != null) { filters.and(createSrcSwitchFilter(srcSwitchId)); } if (srcPort != null) { filters.and(new Filter(SRC_PORT_PROPERTY_NAME, ComparisonOperator.EQUALS, srcPort)); } if (dstSwitchId != null) { filters.and(createDstSwitchFilter(dstSwitchId)); } if (dstPort != null) { filters.and(new Filter(DST_PORT_PROPERTY_NAME, ComparisonOperator.EQUALS, dstPort)); } return getSession().loadAll(getEntityType(), filters, DEPTH_LOAD_ENTITY); }
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)); } }
/** * @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)"); }
/** * @see DATAGRAPH-445 */ @Test public void testFindByChainedAndedProperties() { Filter planetParam = new Filter("name", ComparisonOperator.EQUALS, "Earth"); planetParam.setNestedPropertyName("collidesWith"); planetParam.setNestedEntityTypeLabel("Planet"); planetParam.setRelationshipType("COLLIDES"); planetParam.setRelationshipDirection("OUTGOING"); Filter moonParam = new Filter("name", ComparisonOperator.EQUALS, "Moon"); moonParam.setNestedPropertyName("moon"); moonParam.setNestedEntityTypeLabel("Moon"); moonParam.setRelationshipType("ORBITS"); moonParam.setRelationshipDirection("INCOMING"); assertThat(queryStatements.findByType("Asteroid", new Filters().add(planetParam).and(moonParam), 1).getStatement()) .isEqualTo("MATCH (n:`Asteroid`) MATCH (m0:`Planet`) WHERE m0.`name` = { `collidesWith_name_0` } " + "MATCH (m1:`Moon`) WHERE m1.`name` = { `moon_name_1` } MATCH (n)-[:`COLLIDES`]->(m0) " + "MATCH (n)<-[:`ORBITS`]-(m1) WITH DISTINCT n MATCH p=(n)-[*0..1]-(m) RETURN p, ID(n)"); }
public Filters add(Filter... additionalFilters) { for (Filter filter : additionalFilters) { this.add(filter); } return this; }
@Override public Optional<Isl> findByEndpoints(SwitchId srcSwitchId, int srcPort, SwitchId dstSwitchId, int dstPort) { Filter srcSwitchFilter = createSrcSwitchFilter(srcSwitchId); Filter srcPortFilter = new Filter(SRC_PORT_PROPERTY_NAME, ComparisonOperator.EQUALS, srcPort); Filter dstSwitchFilter = createDstSwitchFilter(dstSwitchId); Filter dstPortFilter = new Filter(DST_PORT_PROPERTY_NAME, ComparisonOperator.EQUALS, dstPort); Collection<Isl> isls = getSession().loadAll(getEntityType(), srcSwitchFilter.and(srcPortFilter).and(dstSwitchFilter).and(dstPortFilter), DEPTH_LOAD_ENTITY); if (isls.size() > 1) { throw new PersistenceException(format("Found more that 1 ISL entity with %s_%d - %s_%d", srcSwitchId, srcPort, dstSwitchId, dstPort)); } return isls.isEmpty() ? Optional.empty() : Optional.of(isls.iterator().next()); }
@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); }
if (filters == null || filters.isEmpty()) { query = queryStatements.findByType(entityLabel, depth); } else {
/** * 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); }
public Filters(Iterable<Filter> filters) { add(filters); }
@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); }
/** * 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); }
@Override public Collection<LinkProps> findByEndpoints(SwitchId srcSwitch, Integer srcPort, SwitchId dstSwitch, Integer dstPort) { Filters filters = new Filters(); if (srcSwitch != null) { filters.and(new Filter(SRC_SWITCH_PROPERTY_NAME, ComparisonOperator.EQUALS, srcSwitch)); } if (srcPort != null) { filters.and(new Filter(SRC_PORT_PROPERTY_NAME, ComparisonOperator.EQUALS, srcPort)); } if (dstSwitch != null) { filters.and(new Filter(DST_SWITCH_PROPERTY_NAME, ComparisonOperator.EQUALS, dstSwitch)); } if (dstPort != null) { filters.and(new Filter(DST_PORT_PROPERTY_NAME, ComparisonOperator.EQUALS, dstPort)); } return getSession().loadAll(getEntityType(), filters, DEPTH_LOAD_ENTITY); } }
public Filters(Filter... filters) { add(filters); }
public <T> Collection<T> loadAll(Class<T> type, SortOrder sortOrder, Pagination pagination, int depth) { return loadAll(type, new Filters(), sortOrder, pagination, depth); } }
/** * 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); }