org.apache.lucene.queryparser.flexible.standard

## Class StandardQueryParser

- java.lang.Object
- - org.apache.lucene.queryparser.flexible.core.QueryParserHelper
  - - org.apache.lucene.queryparser.flexible.standard.StandardQueryParser

- All Implemented Interfaces:
    CommonQueryParserConfiguration
  Direct Known Subclasses:
    PrecedenceQueryParser

      public class StandardQueryParser
      extends QueryParserHelper
      implements CommonQueryParserConfiguration

  This class is a helper that enables users to easily use the Lucene query parser.

  To construct a Query object from a query string, use the `parse(String, String)` method:

       StandardQueryParser queryParserHelper = new StandardQueryParser();
       Query query = queryParserHelper.parse("a AND b", "defaultField");

  To change any configuration before parsing the query string do, for example:

       // the query config handler returned by StandardQueryParser is a StandardQueryConfigHandler
       queryParserHelper.getQueryConfigHandler().setAnalyzer(new WhitespaceAnalyzer());

  The syntax for query strings is as follows (copied from the old QueryParser javadoc): A Query is a series of clauses. A clause may be prefixed by:

  - a plus (`+`) or a minus (`-`) sign, indicating that the clause is required or prohibited respectively; or
  - a term followed by a colon, indicating the field to be searched. This enables one to construct queries which search multiple fields.
  A clause may be either:
  - a term, indicating all the documents that contain this term; or
  - a nested query, enclosed in parentheses. Note that this may be used with a `+`/`-` prefix to require any of a set of terms.
  Thus, in BNF, the query grammar is:

         Query  ::= ( Clause )*
         Clause ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")" )

  Examples of appropriately formatted queries can be found in the query syntax documentation.

  The text parser used by this helper is a `StandardSyntaxParser`.

  The query node processor used by this helper is a `StandardQueryNodeProcessorPipeline`.

  The builder used by this helper is a `StandardQueryTreeBuilder`.

  See Also:
    `StandardQueryParser`, `StandardQueryConfigHandler`, `StandardSyntaxParser`, `StandardQueryNodeProcessorPipeline`, `StandardQueryTreeBuilder`

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `StandardQueryParser()` Constructs a `StandardQueryParser` object.
    `StandardQueryParser(Analyzer analyzer)` Constructs a `StandardQueryParser` object and sets an `Analyzer` to it.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `getAllowLeadingWildcard()`
    `Analyzer` | `getAnalyzer()`
    `DateTools.Resolution` | `getDateResolution()` Returns the default `DateTools.Resolution` used for certain field when no `DateTools.Resolution` is defined for this field.
    `Map<CharSequence,DateTools.Resolution>` | `getDateResolutionMap()` Returns the field to `DateTools.Resolution` map used to normalize each date field.
    `StandardQueryConfigHandler.Operator` | `getDefaultOperator()` Gets implicit operator setting, which will be either `StandardQueryConfigHandler.Operator.AND` or `StandardQueryConfigHandler.Operator.OR`.
    `boolean` | `getEnablePositionIncrements()`
    `Map<String,Float>` | `getFieldsBoost()` Returns the field to boost map used to set boost for each field.
    `float` | `getFuzzyMinSim()` Get the minimal similarity for fuzzy queries.
    `int` | `getFuzzyPrefixLength()` Get the prefix length for fuzzy queries.
    `Locale` | `getLocale()` Returns current locale, allowing access by subclasses.
    `CharSequence[]` | `getMultiFields()` Returns the fields used to expand the query when the field for a certain query is `null`
    `MultiTermQuery.RewriteMethod` | `getMultiTermRewriteMethod()`
    `int` | `getPhraseSlop()` Gets the default slop for phrases.
    `Map<String,PointsConfig>` | `getPointsConfigMap()`
    `TimeZone` | `getTimeZone()`
    `Query` | `parse(String query, String defaultField)` Overrides `QueryParserHelper.parse(String, String)` so it casts the return object to `Query`.
    `void` | `setAllowLeadingWildcard(boolean allowLeadingWildcard)` Set to `true` to allow leading wildcard characters.
    `void` | `setAnalyzer(Analyzer analyzer)`
    `void` | `setDateResolution(DateTools.Resolution dateResolution)` Sets the default `DateTools.Resolution` used for certain field when no `DateTools.Resolution` is defined for this field.
    `void` | `setDateResolutionMap(Map<CharSequence,DateTools.Resolution> dateRes)` Sets the `DateTools.Resolution` used for each field
    `void` | `setDefaultOperator(StandardQueryConfigHandler.Operator operator)` Sets the boolean operator of the QueryParser.
    `void` | `setEnablePositionIncrements(boolean enabled)` Set to `true` to enable position increments in result query.
    `void` | `setFieldsBoost(Map<String,Float> boosts)` Sets the boost used for each field.
    `void` | `setFuzzyMinSim(float fuzzyMinSim)` Set the minimum similarity for fuzzy queries.
    `void` | `setFuzzyPrefixLength(int fuzzyPrefixLength)` Set the prefix length for fuzzy queries.
    `void` | `setLocale(Locale locale)` Set locale used by date range parsing.
    `void` | `setMultiFields(CharSequence[] fields)` Set the fields a query should be expanded to when the field is `null`
    `void` | `setMultiTermRewriteMethod(MultiTermQuery.RewriteMethod method)` By default, it uses `MultiTermQuery.CONSTANT_SCORE_REWRITE` when creating a prefix, wildcard and range queries.
    `void` | `setPhraseSlop(int defaultPhraseSlop)` Sets the default slop for phrases.
    `void` | `setPointsConfigMap(Map<String,PointsConfig> pointsConfigMap)`
    `void` | `setTimeZone(TimeZone timeZone)`
    `String` | `toString()`

    - ### Methods inherited from class org.apache.lucene.queryparser.flexible.core.QueryParserHelper

      `getQueryBuilder, getQueryConfigHandler, getQueryNodeProcessor, getSyntaxParser, setQueryBuilder, setQueryConfigHandler, setQueryNodeProcessor, setSyntaxParser`

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

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

- - ### Constructor Detail

    - #### StandardQueryParser

          public StandardQueryParser()

      Constructs a `StandardQueryParser` object.

    - #### StandardQueryParser

          public StandardQueryParser(Analyzer analyzer)

      Constructs a `StandardQueryParser` object and sets an `Analyzer` to it. The same as:

           StandardQueryParser qp = new StandardQueryParser();
           qp.getQueryConfigHandler().setAnalyzer(analyzer);

      Parameters:
        `analyzer` - the analyzer to be used by this query parser helper

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### parse

          public Query parse(String query,
                             String defaultField)
                      throws QueryNodeException

      Overrides `QueryParserHelper.parse(String, String)` so it casts the return object to `Query`. For more reference about this method, check `QueryParserHelper.parse(String, String)`.
      Overrides:
        `parse` in class `QueryParserHelper`
      Parameters:
        `query` - the query string
        `defaultField` - the default field used by the text parser
      Returns:
        the object built from the query
      Throws:
        `QueryNodeException` - if something wrong happens along the three phases

    - #### getDefaultOperator

          public StandardQueryConfigHandler.Operator getDefaultOperator()

      Gets implicit operator setting, which will be either `StandardQueryConfigHandler.Operator.AND` or `StandardQueryConfigHandler.Operator.OR`.

    - #### setDefaultOperator

          public void setDefaultOperator(StandardQueryConfigHandler.Operator operator)

      Sets the boolean operator of the QueryParser. In default mode ( `StandardQueryConfigHandler.Operator.OR`) terms without any modifiers are considered optional: for example `capital of Hungary` is equal to `capital OR of OR Hungary`.
      In `StandardQueryConfigHandler.Operator.AND` mode terms are considered to be in conjunction: the above mentioned query is parsed as `capital AND of AND Hungary`

    - #### setAllowLeadingWildcard

          public void setAllowLeadingWildcard(boolean allowLeadingWildcard)

      Set to `true` to allow leading wildcard characters.

      When set, `*` or `?` are allowed as the first character of a PrefixQuery and WildcardQuery. Note that this can produce very slow queries on big indexes.

      Default: false.

      Specified by:
        `setAllowLeadingWildcard` in interface `CommonQueryParserConfiguration`

    - #### setEnablePositionIncrements

          public void setEnablePositionIncrements(boolean enabled)

      Set to `true` to enable position increments in result query.

      When set, result phrase and multi-phrase queries will be aware of position increments. Useful when e.g. a StopFilter increases the position increment of the token that follows an omitted token.

      Default: false.

      Specified by:
        `setEnablePositionIncrements` in interface `CommonQueryParserConfiguration`

    - #### getEnablePositionIncrements

          public boolean getEnablePositionIncrements()

      Specified by:
        `getEnablePositionIncrements` in interface `CommonQueryParserConfiguration`
      See Also:
        `setEnablePositionIncrements(boolean)`

    - #### setMultiTermRewriteMethod

          public void setMultiTermRewriteMethod(MultiTermQuery.RewriteMethod method)

      By default, it uses `MultiTermQuery.CONSTANT_SCORE_REWRITE` when creating a prefix, wildcard and range queries. This implementation is generally preferable because it a) Runs faster b) Does not have the scarcity of terms unduly influence score c) avoids any `TooManyListenersException` exception. However, if your application really needs to use the old-fashioned boolean queries expansion rewriting and the above points are not relevant then use this change the rewrite method.
      Specified by:
        `setMultiTermRewriteMethod` in interface `CommonQueryParserConfiguration`

    - #### getMultiTermRewriteMethod

          public MultiTermQuery.RewriteMethod getMultiTermRewriteMethod()

      Specified by:
        `getMultiTermRewriteMethod` in interface `CommonQueryParserConfiguration`
      See Also:
        `setMultiTermRewriteMethod(org.apache.lucene.search.MultiTermQuery.RewriteMethod)`

    - #### setMultiFields

          public void setMultiFields(CharSequence[] fields)

      Set the fields a query should be expanded to when the field is `null`
      Parameters:
        `fields` - the fields used to expand the query

    - #### getMultiFields

          public CharSequence[] getMultiFields()

      Returns the fields used to expand the query when the field for a certain query is `null`
      Returns:
        the fields used to expand the query

    - #### setFuzzyPrefixLength

          public void setFuzzyPrefixLength(int fuzzyPrefixLength)

      Set the prefix length for fuzzy queries. Default is 0.
      Specified by:
        `setFuzzyPrefixLength` in interface `CommonQueryParserConfiguration`
      Parameters:
        `fuzzyPrefixLength` - The fuzzyPrefixLength to set.

    - #### setPointsConfigMap

          public void setPointsConfigMap(Map<String,PointsConfig> pointsConfigMap)

    - #### getPointsConfigMap

          public Map<String,PointsConfig> getPointsConfigMap()

    - #### setLocale

          public void setLocale(Locale locale)

      Set locale used by date range parsing.
      Specified by:
        `setLocale` in interface `CommonQueryParserConfiguration`

    - #### getLocale

          public Locale getLocale()

      Returns current locale, allowing access by subclasses.
      Specified by:
        `getLocale` in interface `CommonQueryParserConfiguration`

    - #### setTimeZone

          public void setTimeZone(TimeZone timeZone)

      Specified by:
        `setTimeZone` in interface `CommonQueryParserConfiguration`

    - #### getTimeZone

          public TimeZone getTimeZone()

      Specified by:
        `getTimeZone` in interface `CommonQueryParserConfiguration`

    - #### setPhraseSlop

          public void setPhraseSlop(int defaultPhraseSlop)

      Sets the default slop for phrases. If zero, then exact phrase matches are required. Default value is zero.
      Specified by:
        `setPhraseSlop` in interface `CommonQueryParserConfiguration`

    - #### setAnalyzer

          public void setAnalyzer(Analyzer analyzer)

    - #### getAnalyzer

          public Analyzer getAnalyzer()

      Specified by:
        `getAnalyzer` in interface `CommonQueryParserConfiguration`

    - #### getAllowLeadingWildcard

          public boolean getAllowLeadingWildcard()

      Specified by:
        `getAllowLeadingWildcard` in interface `CommonQueryParserConfiguration`
      See Also:
        `setAllowLeadingWildcard(boolean)`

    - #### getFuzzyMinSim

          public float getFuzzyMinSim()

      Get the minimal similarity for fuzzy queries.
      Specified by:
        `getFuzzyMinSim` in interface `CommonQueryParserConfiguration`

    - #### getFuzzyPrefixLength

          public int getFuzzyPrefixLength()

      Get the prefix length for fuzzy queries.
      Specified by:
        `getFuzzyPrefixLength` in interface `CommonQueryParserConfiguration`
      Returns:
        Returns the fuzzyPrefixLength.

    - #### getPhraseSlop

          public int getPhraseSlop()

      Gets the default slop for phrases.
      Specified by:
        `getPhraseSlop` in interface `CommonQueryParserConfiguration`

    - #### setFuzzyMinSim

          public void setFuzzyMinSim(float fuzzyMinSim)

      Set the minimum similarity for fuzzy queries. Default is defined on `FuzzyQuery.defaultMinSimilarity`.
      Specified by:
        `setFuzzyMinSim` in interface `CommonQueryParserConfiguration`

    - #### setFieldsBoost

          public void setFieldsBoost(Map<String,Float> boosts)

      Sets the boost used for each field.
      Parameters:
        `boosts` - a collection that maps a field to its boost

    - #### getFieldsBoost

          public Map<String,Float> getFieldsBoost()

      Returns the field to boost map used to set boost for each field.
      Returns:
        the field to boost map

    - #### setDateResolution

          public void setDateResolution(DateTools.Resolution dateResolution)

      Sets the default `DateTools.Resolution` used for certain field when no `DateTools.Resolution` is defined for this field.
      Specified by:
        `setDateResolution` in interface `CommonQueryParserConfiguration`
      Parameters:
        `dateResolution` - the default `DateTools.Resolution`

    - #### getDateResolution

          public DateTools.Resolution getDateResolution()

      Returns the default `DateTools.Resolution` used for certain field when no `DateTools.Resolution` is defined for this field.
      Returns:
        the default `DateTools.Resolution`

    - #### getDateResolutionMap

          public Map<CharSequence,DateTools.Resolution> getDateResolutionMap()

      Returns the field to `DateTools.Resolution` map used to normalize each date field.
      Returns:
        the field to `DateTools.Resolution` map

    - #### setDateResolutionMap

          public void setDateResolutionMap(Map<CharSequence,DateTools.Resolution> dateRes)

      Sets the `DateTools.Resolution` used for each field
      Parameters:
        `dateRes` - a collection that maps a field to its `DateTools.Resolution`

Copyright © 2000-2024 Apache Software Foundation. All Rights Reserved.