Package org.apache.lucene.search

# Class UsageTrackingQueryCachingPolicy

java.lang.Object
org.apache.lucene.search.UsageTrackingQueryCachingPolicy

All Implemented Interfaces:
  `QueryCachingPolicy`

public class UsageTrackingQueryCachingPolicy extends Object implements QueryCachingPolicy
A `QueryCachingPolicy` that tracks usage statistics of recently-used filters in order to decide on which filters are worth caching.

WARNING: This API is experimental and might change in incompatible ways in the next release.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `UsageTrackingQueryCachingPolicy()`
  Create a new instance with an history size of 256.
  `UsageTrackingQueryCachingPolicy(int historySize)`
  Expert: Create a new instance with a configurable history size.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected int`
  `minFrequencyToCache(Query query)`
  For a given filter, return how many times it should appear in the history before being cached.
  `void`
  `onUse(Query query)`
  Callback that is called every time that a cached filter is used.
  `boolean`
  `shouldCache(Query query)`
  Whether the given `Query` is worth caching.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### UsageTrackingQueryCachingPolicy

    public UsageTrackingQueryCachingPolicy(int historySize)
    Expert: Create a new instance with a configurable history size. Beware of passing too large values for the size of the history, either `minFrequencyToCache(org.apache.lucene.search.Query)` returns low values and this means some filters that are rarely used will be cached, which would hurt performance. Or `minFrequencyToCache(org.apache.lucene.search.Query)` returns high values that are function of the size of the history but then filters will be slow to make it to the cache.
    Parameters:
      `historySize` - the number of recently used filters to track

  - ### UsageTrackingQueryCachingPolicy

    public UsageTrackingQueryCachingPolicy()
    Create a new instance with an history size of 256. This should be a good default for most cases.

- ## Method Details

  - ### minFrequencyToCache

    protected int minFrequencyToCache(Query query)
    For a given filter, return how many times it should appear in the history before being cached. The default implementation returns 2 for filters that need to evaluate against the entire index to build a `DocIdSetIterator`, like `MultiTermQuery`, point-based queries or `TermInSetQuery`, and 5 for other filters.

  - ### onUse

    public void onUse(Query query)
    Description copied from interface: `QueryCachingPolicy`
    Callback that is called every time that a cached filter is used. This is typically useful if the policy wants to track usage statistics in order to make decisions.
    Specified by:
      `onUse` in interface `QueryCachingPolicy`

  - ### shouldCache

    public boolean shouldCache(Query query) throws IOException
    Description copied from interface: `QueryCachingPolicy`
    Whether the given `Query` is worth caching. This method will be called by the `QueryCache` to know whether to cache. It will first attempt to load a `DocIdSet` from the cache. If it is not cached yet and this method returns `true` then a cache entry will be generated. Otherwise an uncached scorer will be returned.
    Specified by:
      `shouldCache` in interface `QueryCachingPolicy`
    Throws:
      `IOException`