Package org.apache.lucene.queryparser.classic

Class QueryParserBase

    • Field Detail

      • AND_OPERATOR

        public static final QueryParser.Operator AND_OPERATOR
        Alternative form of QueryParser.Operator.AND

      • OR_OPERATOR

        public static final QueryParser.Operator OR_OPERATOR
        Alternative form of QueryParser.Operator.OR

      • field

        protected String field

    • Constructor Detail

      • QueryParserBase

        protected QueryParserBase()

    • Method Detail

      • init

        public void init​(String f,
                 Analyzer a)
        Initializes a query parser. Called by the QueryParser constructor
        Parameters:
        f - the default field for query terms.
        a - used to find terms in the query text.

      • ReInit

        public abstract void ReInit​(CharStream stream)

      • getField

        public String getField()
        Returns:
        Returns the default field.

      • setAutoGeneratePhraseQueries

        public void setAutoGeneratePhraseQueries​(boolean value)
        Set to true if phrase queries will be automatically generated when the analyzer returns more than one term from whitespace delimited text. NOTE: this behavior may not be suitable for all languages.

        Set to false if phrase queries should only be generated when surrounded by double quotes.

      • 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.

      • setPhraseSlop

        public void setPhraseSlop​(int phraseSlop)
        Sets the default slop for phrases. If zero, then exact phrase matches are required. Default value is zero.
        Specified by:
        setPhraseSlop in interface CommonQueryParserConfiguration

      • 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

      • setDefaultOperator

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

      • getDefaultOperator

        public QueryParser.Operator getDefaultOperator()
        Gets implicit operator setting, which will be either AND_OPERATOR or OR_OPERATOR.

      • setDateResolution

        public void setDateResolution​(String fieldName,
                              DateTools.Resolution dateResolution)
        Sets the date resolution used by RangeQueries for a specific field.
        Parameters:
        fieldName - field for which the date resolution is to be set
        dateResolution - date resolution to set

      • getDateResolution

        public DateTools.Resolution getDateResolution​(String fieldName)
        Returns the date resolution that is used by RangeQueries for the given field. Returns null, if no default or field specific date resolution has been set for the given field.

      • setDeterminizeWorkLimit

        public void setDeterminizeWorkLimit​(int determinizeWorkLimit)
        Parameters:
        determinizeWorkLimit - the maximum effort that determinizing a regexp query can spend. If the query requires more effort, a TooComplexToDeterminizeException is thrown.

      • getDeterminizeWorkLimit

        public int getDeterminizeWorkLimit()
        Returns:
        the maximum effort that determinizing a regexp query can spend. If the query requires more effort, a TooComplexToDeterminizeException is thrown.

      • addMultiTermClauses

        protected void addMultiTermClauses​(List<BooleanClause> clauses,
                                   Query q)
        Adds clauses generated from analysis over text containing whitespace. There are no operators, so the query's clauses can either be MUST (if the default operator is AND) or SHOULD (default OR).

        If all of the clauses in the given Query are TermQuery-s, this method flattens the result by adding the TermQuery-s individually to the output clause list; otherwise, the given Query is added as a single clause including its nested clauses.

      • newBooleanClause

        protected BooleanClause newBooleanClause​(Query q,
                                         BooleanClause.Occur occur)
        Builds a new BooleanClause instance
        Parameters:
        q - sub query
        occur - how this clause should occur when matching documents
        Returns:
        new BooleanClause instance

      • newPrefixQuery

        protected Query newPrefixQuery​(Term prefix)
        Builds a new PrefixQuery instance
        Parameters:
        prefix - Prefix term
        Returns:
        new PrefixQuery instance

      • newRegexpQuery

        protected Query newRegexpQuery​(Term regexp)
        Builds a new RegexpQuery instance
        Parameters:
        regexp - Regexp term
        Returns:
        new RegexpQuery instance

      • newFuzzyQuery

        protected Query newFuzzyQuery​(Term term,
                              float minimumSimilarity,
                              int prefixLength)
        Builds a new FuzzyQuery instance
        Parameters:
        term - Term
        minimumSimilarity - minimum similarity
        prefixLength - prefix length
        Returns:
        new FuzzyQuery Instance

      • newRangeQuery

        protected Query newRangeQuery​(String field,
                              String part1,
                              String part2,
                              boolean startInclusive,
                              boolean endInclusive)
        Builds a new TermRangeQuery instance
        Parameters:
        field - Field
        part1 - min
        part2 - max
        startInclusive - true if the start of the range is inclusive
        endInclusive - true if the end of the range is inclusive
        Returns:
        new TermRangeQuery instance

      • newMatchAllDocsQuery

        protected Query newMatchAllDocsQuery()
        Builds a new MatchAllDocsQuery instance
        Returns:
        new MatchAllDocsQuery instance

      • newWildcardQuery

        protected Query newWildcardQuery​(Term t)
        Builds a new WildcardQuery instance
        Parameters:
        t - wildcard term
        Returns:
        new WildcardQuery instance

      • getBooleanQuery

        protected Query getBooleanQuery​(List<BooleanClause> clauses)
                         throws ParseException
        Factory method for generating query, given a set of clauses. By default creates a boolean query composed of clauses passed in.

        Can be overridden by extending classes, to modify query being returned.

        Parameters:
        clauses - List that contains BooleanClause instances to join.
        Returns:
        Resulting Query object.
        Throws:
        ParseException - throw in overridden method to disallow

      • getWildcardQuery

        protected Query getWildcardQuery​(String field,
                                 String termStr)
                          throws ParseException
        Factory method for generating a query. Called when parser parses an input term token that contains one or more wildcard characters (? and *), but is not a prefix term token (one that has just a single * character at the end)

        Depending on settings, prefix term may be lower-cased automatically. It will not go through the default Analyzer, however, since normal Analyzers are unlikely to work properly with wildcard templates.

        Can be overridden by extending classes, to provide custom handling for wildcard queries, which may be necessary due to missing analyzer calls.

        Parameters:
        field - Name of the field query will use.
        termStr - Term token that contains one or more wild card characters (? or *), but is not simple prefix term
        Returns:
        Resulting Query built for the term
        Throws:
        ParseException - throw in overridden method to disallow

      • getRegexpQuery

        protected Query getRegexpQuery​(String field,
                               String termStr)
                        throws ParseException
        Factory method for generating a query. Called when parser parses an input term token that contains a regular expression query.

        Depending on settings, pattern term may be lower-cased automatically. It will not go through the default Analyzer, however, since normal Analyzers are unlikely to work properly with regular expression templates.

        Can be overridden by extending classes, to provide custom handling for regular expression queries, which may be necessary due to missing analyzer calls.

        Parameters:
        field - Name of the field query will use.
        termStr - Term token that contains a regular expression
        Returns:
        Resulting Query built for the term
        Throws:
        ParseException - throw in overridden method to disallow

      • getPrefixQuery

        protected Query getPrefixQuery​(String field,
                               String termStr)
                        throws ParseException
        Factory method for generating a query (similar to getWildcardQuery(java.lang.String, java.lang.String)). Called when parser parses an input term token that uses prefix notation; that is, contains a single '*' wildcard character as its last character. Since this is a special case of generic wildcard term, and such a query can be optimized easily, this usually results in a different query object.

        Depending on settings, a prefix term may be lower-cased automatically. It will not go through the default Analyzer, however, since normal Analyzers are unlikely to work properly with wildcard templates.

        Can be overridden by extending classes, to provide custom handling for wild card queries, which may be necessary due to missing analyzer calls.

        Parameters:
        field - Name of the field query will use.
        termStr - Term token to use for building term for the query (without trailing '*' character!)
        Returns:
        Resulting Query built for the term
        Throws:
        ParseException - throw in overridden method to disallow

      • getFuzzyQuery

        protected Query getFuzzyQuery​(String field,
                              String termStr,
                              float minSimilarity)
                       throws ParseException
        Factory method for generating a query (similar to getWildcardQuery(java.lang.String, java.lang.String)). Called when parser parses an input term token that has the fuzzy suffix (~) appended.
        Parameters:
        field - Name of the field query will use.
        termStr - Term token to use for building term for the query
        Returns:
        Resulting Query built for the term
        Throws:
        ParseException - throw in overridden method to disallow

      • getFuzzyDistance

        protected float getFuzzyDistance​(Token fuzzyToken,
                                 String termStr)
        Determines the similarity distance for the given fuzzy token and term string.

        The default implementation uses the string image of the fuzzyToken in an attempt to parse it to a primitive float value. Otherwise, the minimal similarity distance is returned. Subclasses can override this method to return a similarity distance, say based on the termStr, if the fuzzyToken does not specify a distance.

        Parameters:
        fuzzyToken - The Fuzzy token
        termStr - The Term string
        Returns:
        The similarity distance

      • escape

        public static String escape​(String s)
        Returns a String where those characters that QueryParser expects to be escaped are escaped by a preceding \.