com.googlecode.cqengine.engine.CollectionQueryEngine Maven / Gradle / Ivy

* This method is recursive. *

* When processing a {@link SimpleQuery}, the method will simply delegate to the helper methods * {@link #retrieveIntersection(Collection, QueryOptions, boolean)} and {@link #retrieveUnion(Collection, QueryOptions)} * and will return their results. *

* When processing a descendant of {@link CompoundQuery} ({@link And}, {@link Or}, {@link Not}), the method * will extract separately from those objects the child queries which are {@link SimpleQuery}s and the child * queries which are {@link CompoundQuery}s. It will call the helper methods above to process the child * {@link SimpleQuery}s, and the method will call itself recursively to process the child {@link CompoundQuery}s. * Once the method has results for both the child {@link SimpleQuery}s and the child {@link CompoundQuery}s, it * will return them in a {@link ResultSetIntersection}, {@link ResultSetUnion} or {@link ResultSetDifference} * object as appropriate for {@link And}, {@link Or}, {@link Not} respectively. These {@link ResultSet} objects * will take care of performing intersections or unions etc. on the child {@link ResultSet}s. * * @param query A query representing some assertions which sought objects must match * @param queryOptions Optional parameters for the query * supplied specifying strategy {@link DeduplicationStrategy#LOGICAL_ELIMINATION} * @return A {@link ResultSet} which provides objects matching the given query */ ResultSet retrieveRecursive(Query query, final QueryOptions queryOptions) { final boolean indexMergeStrategyEnabled = isFlagEnabled(queryOptions, PREFER_INDEX_MERGE_STRATEGY); // Check if we can process this query from a standing query index... Index standingQueryIndex = standingQueryIndexes.get(query); if (standingQueryIndex != null) { // No deduplication required for standing queries. if (standingQueryIndex instanceof StandingQueryIndex) { return standingQueryIndex.retrieve(query, queryOptions); } else { return standingQueryIndex.retrieve(equal(forStandingQuery(query), Boolean.TRUE), queryOptions); } } // else no suitable standing query index exists, process the query normally... if (query instanceof SimpleQuery) { // No deduplication required for a single SimpleQuery. // Return the ResultSet from the index with the lowest retrieval cost which supports // this query and the attribute on which it is based... return getResultSetWithLowestRetrievalCost((SimpleQuery) query, queryOptions); } else if (query instanceof And) { final And and = (And) query; // Check if we can process this And query from a compound index... if (!compoundIndexes.isEmpty()) { // Compound indexes exist. Check if any can be used for this And query... CompoundQuery compoundQuery = CompoundQuery.fromAndQueryIfSuitable(and); if (compoundQuery != null) { CompoundIndex compoundIndex = compoundIndexes.get(compoundQuery.getCompoundAttribute()); if (compoundIndex != null && compoundIndex.supportsQuery(compoundQuery, queryOptions)) { // No deduplication required for retrievals from compound indexes. return compoundIndex.retrieve(compoundQuery, queryOptions); } } } // else no suitable compound index exists, process the And query normally... // No deduplication required for intersections. return new ResultSetIntersection(new Iterable>() { @Override public Iterator> iterator() { return new UnmodifiableIterator>() { boolean needToProcessSimpleQueries = and.hasSimpleQueries(); Iterator> logicalQueriesIterator = and.getLogicalQueries().iterator(); @Override public boolean hasNext() { return needToProcessSimpleQueries || logicalQueriesIterator.hasNext(); } @Override public ResultSet next() { if (needToProcessSimpleQueries) { needToProcessSimpleQueries = false; // Retrieve results for simple queries from indexes... return retrieveIntersection(and.getSimpleQueries(), queryOptions, indexMergeStrategyEnabled); } // Recursively call this method for logical queries... return retrieveRecursive(logicalQueriesIterator.next(), queryOptions); } }; } }, query, queryOptions, indexMergeStrategyEnabled); } else if (query instanceof Or) { final Or or = (Or) query; // If the Or query indicates child queries are disjoint, // ignore any instruction to perform deduplication in the queryOptions supplied... final QueryOptions queryOptionsForOrUnion; if (or.isDisjoint()) { // The Or query is disjoint, so there is no need to perform deduplication on its results. // Wrap the QueryOptions object in another which omits the DeduplicationOption if it is requested // when evaluating this Or statement... queryOptionsForOrUnion = new QueryOptions(queryOptions.getOptions()) { @Override public Object get(Object key) { return DeduplicationOption.class.equals(key) ? null : super.get(key); } }; } else { // Use the supplied queryOptions... queryOptionsForOrUnion = queryOptions; } Iterable> resultSetsToUnion = new Iterable>() { @Override public Iterator> iterator() { return new UnmodifiableIterator>() { boolean needToProcessSimpleQueries = or.hasSimpleQueries(); Iterator> logicalQueriesIterator = or.getLogicalQueries().iterator(); @Override public boolean hasNext() { return needToProcessSimpleQueries || logicalQueriesIterator.hasNext(); } @Override public ResultSet next() { if (needToProcessSimpleQueries) { needToProcessSimpleQueries = false; // Retrieve results for simple queries from indexes... return retrieveUnion(or.getSimpleQueries(), queryOptionsForOrUnion); } // Recursively call this method for logical queries. // Note we supply the original queryOptions for recursive calls... return retrieveRecursive(logicalQueriesIterator.next(), queryOptions); } }; } }; // *** Deduplication can be required for unions... *** if (DeduplicationOption.isLogicalElimination(queryOptionsForOrUnion)) { return new ResultSetUnion(resultSetsToUnion, query, queryOptions, indexMergeStrategyEnabled); } else { return new ResultSetUnionAll(resultSetsToUnion, query, queryOptions); } } else if (query instanceof Not) { final Not not = (Not) query; // No deduplication required for negation (the entire collection is a Set, contains no duplicates). // Retrieve the ResultSet for the negated query, by calling this method recursively... ResultSet resultSetToNegate = retrieveRecursive(not.getNegatedQuery(), queryOptions); // Return the negation of this result set, by subtracting it from the entire collection of objects... return new ResultSetDifference(getEntireCollectionAsResultSet(query, queryOptions), resultSetToNegate, query, queryOptions, indexMergeStrategyEnabled); } else { throw new IllegalStateException("Unexpected type of query object: " + getClassNameNullSafe(query)); } } /** * Retrieves an intersection of the objects matching {@link SimpleQuery}s. *

* Definitions: * For a definition of retrieval cost see {@link ResultSet#getRetrievalCost()}. * For a definition of merge cost see {@link ResultSet#getMergeCost()}. * *

* The algorithm employed by this method is as follows. *

* For each {@link SimpleQuery} supplied, retrieves a {@link ResultSet} for that {@link SimpleQuery} * from the index with the lowest retrieval cost which supports that {@link SimpleQuery}. *

* The algorithm then determines the {@link ResultSet} with the lowest merge cost, and the * {@link SimpleQuery} which was associated with that {@link ResultSet}. It also assembles a list of the * other {@link SimpleQuery}s which had more expensive merge costs. *

* The algorithm then returns a {@link FilteringResultSet} which iterates the {@link ResultSet} with the * lowest merge cost. During iteration, this {@link FilteringResultSet} calls a * {@link FilteringResultSet#isValid(Object, com.googlecode.cqengine.query.option.QueryOptions)} method for each object. This algorithm implements that method to * return true if the object matches all of the {@link SimpleQuery}s which had the more expensive * merge costs. *