boolQueryFilter.must( FilterBuilders.orFilter( typeTerms ) );
OrFilterBuilder b = FilterBuilders.orFilter(); for (Condition c : condition.getChildren()) { b.add(getFilter(c,informations));
private FilterBuilder orFilters(List<FilterBuilder> filters) { if (filters.size() == 1) { return filters.get(0); } else { return FilterBuilders.orFilter(filters.toArray(new FilterBuilder[filters.size()])); } }
private FilterBuilder getSingleFilterOrOrTheFilters(List<FilterBuilder> filters, HasContainer has) { if (filters.size() > 1) { return FilterBuilders.orFilter(filters.toArray(new FilterBuilder[filters.size()])); } else if (filters.size() == 1) { return filters.get(0); } else { throw new VertexiumException("Unexpected filter count, expected at least 1 filter for: " + has); } }
private FilterBuilder getFilterForHasExtendedData(HasExtendedData has) { List<FilterBuilder> filters = new ArrayList<>(); for (HasExtendedDataFilter hasExtendedDataFilter : has.getFilters()) { filters.add(getFilterForHasExtendedDataFilter(hasExtendedDataFilter)); } return FilterBuilders.orFilter(filters.toArray(new FilterBuilder[filters.size()])); }
FilterBuilder fb = mustMatchAll ? FilterBuilders.andFilter() : FilterBuilders.orFilter(); boolean noop = true; boolean one = terms.size() == 1;
@Override protected Pair<SearchRequestBuilder,QueryBuilder> addSearchSiteIds(Pair<SearchRequestBuilder,QueryBuilder> builders, List<String> siteIds) { SearchRequestBuilder searchRequestBuilder = builders.getLeft(); BoolQueryBuilder queryBuilder = (BoolQueryBuilder)builders.getRight(); // if we have sites filter results to include only the sites included if (siteIds.size() > 0) { searchRequestBuilder = searchRequestBuilder.setRouting(siteIds.toArray(new String[siteIds.size()])); // creating config whether or not to use filter, there are performance and caching differences that // maybe implementation decisions if (useSiteFilters) { OrFilterBuilder siteFilter = orFilter().add( termsFilter(SearchService.FIELD_SITEID, siteIds.toArray(new String[siteIds.size()])).execution("bool")); searchRequestBuilder = searchRequestBuilder.setPostFilter(siteFilter); } else { queryBuilder = queryBuilder.must(termsQuery(SearchService.FIELD_SITEID, siteIds.toArray(new String[siteIds.size()]))); } } return pairOf(searchRequestBuilder,queryBuilder); }
if (resolutionFilters.size() > 0) { final OrFilterBuilder OrResolutionFilterBuilder = FilterBuilders .orFilter(); for (final String resolution : resolutionFilters) { OrResolutionFilterBuilder.add(FilterBuilders.termFilter( .orFilter(); for (final String memory : memoryFilters) { OrMemoryFilterBuilder.add(FilterBuilders.termFilter(
@Override public Map<Object, Set<Edge>> edges(Iterator<BaseVertex> vertices, Direction direction, String[] edgeLabels, Predicates predicates) { List<Object> vertexIds = new ArrayList<>(); vertices.forEachRemaining(singleVertex -> vertexIds.add(singleVertex.id())); BoolFilterBuilder boolFilter = ElasticHelper.createFilterBuilder(predicates.hasContainers); OrFilterBuilder mappingFilter = FilterBuilders.orFilter(); boolean empty = true; for (EdgeMapping mapping : edgeMappings) { if (edgeLabels != null && edgeLabels.length > 0 && !contains(edgeLabels, mapping.getLabel())) continue; mappingFilter.add(FilterBuilders.termsFilter(mapping.getExternalVertexField(), vertexIds.toArray())); empty = false; } if (!empty) { boolFilter.must(mappingFilter); } QueryIterator<Vertex> vertexSearchQuery = new QueryIterator<>(boolFilter, 0, scrollSize, predicates.limitHigh - predicates.limitLow, client, this::createVertex, refresh, timing, indices); Map<Object, Set<Edge>> results = new HashMap<>(); vertexSearchQuery.forEachRemaining(otherVertex -> otherVertex.edges(direction, edgeLabels).forEachRemaining(edge -> { Vertex vertex = BaseVertex.vertexToVertex(otherVertex, edge, direction); Set<Edge> resultEdges = results.get(vertex.id()); if (resultEdges == null) { resultEdges = new HashSet<>(); results.put(vertex.id(), resultEdges); } resultEdges.add(edge); })); return results; }
@Override public Map<Object, Set<Edge>> edges(Iterator<BaseVertex> vertices, Direction direction, String[] edgeLabels, Predicates predicates) { Map<Object, Vertex> idToVertex = new HashMap<>(); vertices.forEachRemaining(singleVertex -> idToVertex.put(singleVertex.id(), singleVertex)); if (edgeLabels != null && edgeLabels.length > 0) predicates.hasContainers.add(new HasContainer(T.label.getAccessor(), P.within(edgeLabels))); Object[] vertexIds = idToVertex.keySet().toArray(); BoolFilterBuilder boolFilter = ElasticHelper.createFilterBuilder(predicates.hasContainers); if (direction == Direction.IN) boolFilter.must(FilterBuilders.termsFilter(DocEdge.InId, vertexIds)); else if (direction == Direction.OUT) boolFilter.must(FilterBuilders.termsFilter(DocEdge.OutId, vertexIds)); else if (direction == Direction.BOTH) boolFilter.must(FilterBuilders.orFilter( FilterBuilders.termsFilter(DocEdge.InId, vertexIds), FilterBuilders.termsFilter(DocEdge.OutId, vertexIds))); QueryIterator<Edge> edgeQueryIterator = new QueryIterator<>(boolFilter, 0, scrollSize, predicates.limitHigh - predicates.limitLow, client, this::createEdge , refresh, timing, indexName); Map<Object, Set<Edge>> results = new HashMap<>(); edgeQueryIterator.forEachRemaining(edge -> edge.vertices(direction).forEachRemaining(vertex -> { Set<Edge> resultEdges = results.get(vertex.id()); if (resultEdges == null) { resultEdges = new HashSet<>(); results.put(vertex.id(), resultEdges); } resultEdges.add(edge); })); return results; }
private FilterBuilder getEdgeFilter() { switch (direction) { case BOTH: FilterBuilder inVertexIdFilter = getDirectionInEdgeFilter(); FilterBuilder outVertexIdFilter = getDirectionOutEdgeFilter(); return FilterBuilders.orFilter(inVertexIdFilter, outVertexIdFilter); case OUT: return getDirectionOutEdgeFilter(); case IN: return getDirectionInEdgeFilter(); default: throw new VertexiumException("unexpected direction: " + direction); } }
/** * Add a filter that check for authorizations on resources * Takes also in account the ALL_USER group */ public static FilterBuilder getResourceAuthorizationFilters() { final Authentication auth = SecurityContextHolder.getContext().getAuthentication(); if (auth.getAuthorities().contains(new SimpleGrantedAuthority(Role.ADMIN.toString()))) { return null; } FilterBuilder filterBuilder; User user = (User) auth.getPrincipal(); if (user.getGroups() != null && !user.getGroups().isEmpty()) { filterBuilder = FilterBuilders.boolFilter() .should(FilterBuilders.nestedFilter("userRoles", FilterBuilders.termFilter("userRoles.key", auth.getName()))) .should(FilterBuilders.nestedFilter("groupRoles", FilterBuilders.inFilter("groupRoles.key", user.getGroups().toArray()))); } else { filterBuilder = FilterBuilders.nestedFilter("userRoles", FilterBuilders.termFilter("userRoles.key", auth.getName())); } Group group = getAllUsersGroup(); if (group != null) { String groupId = group.getId(); // add ALL_USERS group as OR filter filterBuilder = FilterBuilders.orFilter(filterBuilder, FilterBuilders.nestedFilter("groupRoles", FilterBuilders.inFilter("groupRoles.key", groupId))); } return filterBuilder; }
@Override public int getPendingDocuments() { try { CountResponse response = client.prepareCount(indexName) .setQuery(filteredQuery(matchAllQuery(), orFilter( missingFilter(SearchService.FIELD_INDEXED), termFilter(SearchService.FIELD_INDEXED, false)))) .execute() .actionGet(); return (int) response.getCount(); } catch (Exception e) { getLog().error("Problem getting pending docs for index builder [" + getName() + "]", e); } return 0; }
filters.add(orFilters.get(0)); } else if (orFilters.size() > 1) { filters.add(FilterBuilders.orFilter(orFilters.toArray(new FilterBuilder[orFilters.size()])));
protected SearchRequestBuilder addFindContentQueueRequestParams(SearchRequestBuilder searchRequestBuilder) { return searchRequestBuilder .setQuery(matchAllQuery()) .setTypes(indexedDocumentType) .setPostFilter( orFilter( missingFilter(SearchService.FIELD_INDEXED), termFilter(SearchService.FIELD_INDEXED, false))) .setSize(contentIndexBatchSize) .addFields(SearchService.FIELD_REFERENCE, SearchService.FIELD_SITEID); }
OrFilterBuilder b = FilterBuilders.orFilter(); for (Condition c : condition.getChildren()) { b.add(getFilter(c,informations));
if(specifications.size() > 1) OrFilterBuilder OrSpecificationFilterBuilder = FilterBuilders.orFilter(); for (Specification specification : specifications)
if (specifications.size() > 1) { final OrFilterBuilder OrSpecificationFilterBuilder = FilterBuilders .orFilter(); for (final Specification specification : specifications) { final FilterBuilder filterBuilder = FilterBuilders.andFilter(
@Override protected Pair<SearchRequestBuilder, QueryBuilder> addSearchSuggestionsSites(Pair<SearchRequestBuilder, QueryBuilder> builders, String currentSite, boolean allMySites) { String currentUser = ""; User user = userDirectoryService.getCurrentUser(); if (user != null) { currentUser = user.getId(); } String[] sites; if (allMySites || currentSite == null) { sites = getAllUsersSites(currentUser); } else { sites = new String[]{currentSite}; } OrFilterBuilder siteFilter = orFilter().add( termsFilter(SearchService.FIELD_SITEID, sites).execution("bool")); SearchRequestBuilder searchRequestBuilder = builders.getLeft() .setRouting(sites) .setPostFilter(siteFilter); return pairOf(searchRequestBuilder, builders.getRight()); }