Package com.google.gerrit.index.query

Class QueryProcessor<T>

java.lang.Object
com.google.gerrit.index.query.QueryProcessor<T>
Direct Known Subclasses:
AccountQueryProcessor, ChangeQueryProcessor, GroupQueryProcessor, ProjectQueryProcessor
public abstract class QueryProcessor<T> extends Object
Lower-level implementation for executing a single query over a secondary index.

Instances are one-time-use. Other singleton classes should inject a Provider rather than holding on to a single instance.

  • Field Details

    • start

      protected int start

  • Constructor Details

  • Method Details

    • setStart

      @CanIgnoreReturnValue public QueryProcessor<T> setStart(int n)

    • enforceVisibility

      @CanIgnoreReturnValue public QueryProcessor<T> enforceVisibility(boolean enforce)
      Specify whether to enforce visibility by filtering out results that are not visible to the user.

      Enforcing visibility may have performance consequences, as the index system may need to post-filter a large number of results to fill even a modest limit.

      If visibility is enforced, the user's queryLimit global capability is also used to bound the total number of results. If this capability is non-positive, this results in the entire query processor being disabled.

      Parameters:
      enforce - whether to enforce visibility.
      Returns:
      this.

    • setUserProvidedLimit

      @CanIgnoreReturnValue public QueryProcessor<T> setUserProvidedLimit(int n)
      Convenience method for API backward compatibility.

    • setUserProvidedLimit

      @CanIgnoreReturnValue public QueryProcessor<T> setUserProvidedLimit(int n, boolean applyDefaultLimit)
      Set an end-user-provided limit on the number of results returned.

      Since this limit is provided by an end user, it may exceed the limit that they are authorized to use. This is allowed; the processor will take multiple possible limits into account and choose the one that makes the most sense.

      Parameters:
      n - limit; zero or negative means no limit.
      applyDefaultLimit - Should the default limit be applied, if n <= 0? For internal queries this should be false. For API endpoints this should be true.
      Returns:
      this.

    • setNoLimit

      @CanIgnoreReturnValue public QueryProcessor<T> setNoLimit(boolean isNoLimit)

    • setAllowIncompleteResults

      @CanIgnoreReturnValue public QueryProcessor<T> setAllowIncompleteResults(boolean allowIncompleteResults)

    • setRequestedFields

      @CanIgnoreReturnValue public QueryProcessor<T> setRequestedFields(Set<String> fields)

    • query

      public QueryResult<T> query(Predicate<T> query) throws QueryParseException
      Query for entities that match a structured query.
      Parameters:
      query - the query.
      Returns:
      results of the query.
      Throws:
      QueryParseException
      See Also:

    • query

      public List<QueryResult<T>> query(List<Predicate<T>> queries) throws QueryParseException
      Perform multiple queries in parallel.

      If querying is disabled, short-circuits the index and returns empty results. Callers that wish to distinguish this case from a query returning no results from the index may call isDisabled() themselves.

      Parameters:
      queries - list of queries.
      Returns:
      results of the queries, one QueryResult per input query, in the same order as the input.
      Throws:
      QueryParseException

    • createOptions

      protected QueryOptions createOptions(IndexConfig indexConfig, int start, int pageSize, int pageSizeMultiplier, int limit, boolean allowIncompleteResults, Set<String> requestedFields)

    • enforceVisibility

      protected abstract Predicate<T> enforceVisibility(Predicate<T> pred)
      Invoked after the query was rewritten. Subclasses must overwrite this method to filter out results that are not visible to the calling user.
      Parameters:
      pred - the query
      Returns:
      the modified query

    • isDisabled

      public boolean isDisabled()
      Check whether querying should be disabled.

      Currently, the only condition that can disable the whole query processor is if both visibility is enforced and the user has a non-positive maximum value for the queryLimit capability.

      If querying is disabled, all calls to query(Predicate) and query(List) will return empty results. This method can be used if callers wish to distinguish this case from a query returning no results from the index.

      Returns:
      true if querying should be disabled.

    • getEffectiveLimit

      public int getEffectiveLimit(Predicate<T> p)

    • getUserQueryLimit

      protected IntSupplier getUserQueryLimit()

    • getInitialPageSize

      protected int getInitialPageSize(int queryLimit)

    • formatForLogging

      protected abstract String formatForLogging(T t)