Example usage for org.apache.lucene.search FuzzyQuery defaultPrefixLength

List of usage examples for org.apache.lucene.search FuzzyQuery defaultPrefixLength

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.search.*
  5. FuzzyQuery
  6. defaultPrefixLength

Introduction

In this page you can find the example usage for org.apache.lucene.search FuzzyQuery defaultPrefixLength.

Prototype

int defaultPrefixLength

To view the source code for org.apache.lucene.search FuzzyQuery defaultPrefixLength.

Click Source Link

Usage

From source file:io.crate.lucene.match.OptionParser.java

License:Apache License

public static ParsedOptions parse(MultiMatchQueryBuilder.Type matchType, @Nullable Map options)
        throws IllegalArgumentException {
    if (options == null) {
        options = Collections.emptyMap();
    } else {//from ww  w . j a v a  2s . co m
        // need a copy. Otherwise manipulations on a shared option will lead to strange race conditions.
        options = new HashMap(options);
    }
    ParsedOptions parsedOptions = new ParsedOptions(floatValue(options, OPTIONS.BOOST, null),
            analyzer(options.remove(OPTIONS.ANALYZER)),
            zeroTermsQuery(options.remove(OPTIONS.ZERO_TERMS_QUERY)),
            intValue(options, OPTIONS.MAX_EXPANSIONS, FuzzyQuery.defaultMaxExpansions),
            fuzziness(options.remove(OPTIONS.FUZZINESS)),
            intValue(options, OPTIONS.PREFIX_LENGTH, FuzzyQuery.defaultPrefixLength),
            transpositions(options.remove(OPTIONS.FUZZY_TRANSPOSITIONS)));

    switch (matchType.matchQueryType()) {
    case BOOLEAN:
        parsedOptions.commonTermsCutoff(floatValue(options, OPTIONS.CUTOFF_FREQUENCY, null));
        parsedOptions.operator(operator(options.remove(OPTIONS.OPERATOR)));
        parsedOptions.minimumShouldMatch(minimumShouldMatch(options.remove(OPTIONS.MINIMUM_SHOULD_MATCH)));
        break;
    case PHRASE:
        parsedOptions.phraseSlop(intValue(options, OPTIONS.SLOP, 0));
        parsedOptions.tieBreaker(floatValue(options, OPTIONS.TIE_BREAKER, null));
        break;
    case PHRASE_PREFIX:
        parsedOptions.phraseSlop(intValue(options, OPTIONS.SLOP, 0));
        parsedOptions.tieBreaker(floatValue(options, OPTIONS.TIE_BREAKER, null));
        parsedOptions.rewrite(rewrite(options.remove(OPTIONS.REWRITE)));
        break;
    }
    if (!options.isEmpty()) {
        raiseIllegalOptions(matchType, options);
    }
    return parsedOptions;
}

From source file:org.codelibs.elasticsearch.index.query.MatchQueryBuilder.java

License:Apache License

public static Optional<MatchQueryBuilder> fromXContent(QueryParseContext parseContext) throws IOException {
    XContentParser parser = parseContext.parser();
    String fieldName = null;// ww  w  . j  av  a  2s . com
    MatchQuery.Type type = MatchQuery.Type.BOOLEAN;
    Object value = null;
    float boost = AbstractQueryBuilder.DEFAULT_BOOST;
    String minimumShouldMatch = null;
    String analyzer = null;
    Operator operator = MatchQueryBuilder.DEFAULT_OPERATOR;
    int slop = MatchQuery.DEFAULT_PHRASE_SLOP;
    Fuzziness fuzziness = null;
    int prefixLength = FuzzyQuery.defaultPrefixLength;
    int maxExpansion = FuzzyQuery.defaultMaxExpansions;
    boolean fuzzyTranspositions = FuzzyQuery.defaultTranspositions;
    String fuzzyRewrite = null;
    boolean lenient = MatchQuery.DEFAULT_LENIENCY;
    Float cutOffFrequency = null;
    ZeroTermsQuery zeroTermsQuery = MatchQuery.DEFAULT_ZERO_TERMS_QUERY;
    String queryName = null;
    String currentFieldName = null;
    XContentParser.Token token;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (parseContext.isDeprecatedSetting(currentFieldName)) {
            // skip
        } else if (token == XContentParser.Token.START_OBJECT) {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName, currentFieldName);
            fieldName = currentFieldName;
            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                } else if (token.isValue()) {
                    if (QUERY_FIELD.match(currentFieldName)) {
                        value = parser.objectText();
                    } else if (TYPE_FIELD.match(currentFieldName)) {
                        String tStr = parser.text();
                        if ("boolean".equals(tStr)) {
                            type = MatchQuery.Type.BOOLEAN;
                        } else if ("phrase".equals(tStr)) {
                            type = MatchQuery.Type.PHRASE;
                        } else if ("phrase_prefix".equals(tStr) || ("phrasePrefix".equals(tStr))) {
                            type = MatchQuery.Type.PHRASE_PREFIX;
                        } else {
                            throw new ParsingException(parser.getTokenLocation(),
                                    "[" + NAME + "] query does not support type " + tStr);
                        }
                    } else if (ANALYZER_FIELD.match(currentFieldName)) {
                        analyzer = parser.text();
                    } else if (AbstractQueryBuilder.BOOST_FIELD.match(currentFieldName)) {
                        boost = parser.floatValue();
                    } else if (SLOP_FIELD.match(currentFieldName)) {
                        slop = parser.intValue();
                    } else if (Fuzziness.FIELD.match(currentFieldName)) {
                        fuzziness = Fuzziness.parse(parser);
                    } else if (PREFIX_LENGTH_FIELD.match(currentFieldName)) {
                        prefixLength = parser.intValue();
                    } else if (MAX_EXPANSIONS_FIELD.match(currentFieldName)) {
                        maxExpansion = parser.intValue();
                    } else if (OPERATOR_FIELD.match(currentFieldName)) {
                        operator = Operator.fromString(parser.text());
                    } else if (MINIMUM_SHOULD_MATCH_FIELD.match(currentFieldName)) {
                        minimumShouldMatch = parser.textOrNull();
                    } else if (FUZZY_REWRITE_FIELD.match(currentFieldName)) {
                        fuzzyRewrite = parser.textOrNull();
                    } else if (FUZZY_TRANSPOSITIONS_FIELD.match(currentFieldName)) {
                        fuzzyTranspositions = parser.booleanValue();
                    } else if (LENIENT_FIELD.match(currentFieldName)) {
                        lenient = parser.booleanValue();
                    } else if (CUTOFF_FREQUENCY_FIELD.match(currentFieldName)) {
                        cutOffFrequency = parser.floatValue();
                    } else if (ZERO_TERMS_QUERY_FIELD.match(currentFieldName)) {
                        String zeroTermsDocs = parser.text();
                        if ("none".equalsIgnoreCase(zeroTermsDocs)) {
                            zeroTermsQuery = MatchQuery.ZeroTermsQuery.NONE;
                        } else if ("all".equalsIgnoreCase(zeroTermsDocs)) {
                            zeroTermsQuery = MatchQuery.ZeroTermsQuery.ALL;
                        } else {
                            throw new ParsingException(parser.getTokenLocation(),
                                    "Unsupported zero_terms_docs value [" + zeroTermsDocs + "]");
                        }
                    } else if (AbstractQueryBuilder.NAME_FIELD.match(currentFieldName)) {
                        queryName = parser.text();
                    } else {
                        throw new ParsingException(parser.getTokenLocation(),
                                "[" + NAME + "] query does not support [" + currentFieldName + "]");
                    }
                } else {
                    throw new ParsingException(parser.getTokenLocation(),
                            "[" + NAME + "] unknown token [" + token + "] after [" + currentFieldName + "]");
                }
            }
        } else {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName,
                    parser.currentName());
            fieldName = parser.currentName();
            value = parser.objectText();
        }
    }

    if (value == null) {
        throw new ParsingException(parser.getTokenLocation(), "No text specified for text query");
    }

    MatchQueryBuilder matchQuery = new MatchQueryBuilder(fieldName, value);
    matchQuery.operator(operator);
    matchQuery.type(type);
    matchQuery.analyzer(analyzer);
    matchQuery.slop(slop);
    matchQuery.minimumShouldMatch(minimumShouldMatch);
    if (fuzziness != null) {
        matchQuery.fuzziness(fuzziness);
    }
    matchQuery.fuzzyRewrite(fuzzyRewrite);
    matchQuery.prefixLength(prefixLength);
    matchQuery.fuzzyTranspositions(fuzzyTranspositions);
    matchQuery.maxExpansions(maxExpansion);
    matchQuery.lenient(lenient);
    if (cutOffFrequency != null) {
        matchQuery.cutoffFrequency(cutOffFrequency);
    }
    matchQuery.zeroTermsQuery(zeroTermsQuery);
    matchQuery.queryName(queryName);
    matchQuery.boost(boost);
    return Optional.of(matchQuery);
}

From source file:org.compass.core.lucene.engine.queryparser.DefaultLuceneQueryParser.java

License:Apache License

public void configure(CompassSettings settings) throws CompassException {
    allowLeadingWildcard = settings//from  w w  w .j  av a2  s .c  o  m
            .getSettingAsBoolean(LuceneEnvironment.QueryParser.DEFAULT_PARSER_ALLOW_LEADING_WILDCARD, true);
    allowConstantScorePrefixQuery = settings.getSettingAsBoolean(
            LuceneEnvironment.QueryParser.DEFAULT_PARSER_ALLOW_CONSTANT_SCORE_PREFIX_QUERY, true);
    fuzzyMinSimilarity = settings.getSettingAsFloat(
            LuceneEnvironment.QueryParser.DEFAULT_PARSER_FUZZY_MIN_SIMILARITY, FuzzyQuery.defaultMinSimilarity);
    fuzzyPrefixLength = settings.getSettingAsInt(
            LuceneEnvironment.QueryParser.DEFAULT_PARSER_FUZZY_PERFIX_LENGTH, FuzzyQuery.defaultPrefixLength);
    String sDefaultOperator = settings.getSetting(LuceneEnvironment.QueryParser.DEFAULT_PARSER_DEFAULT_OPERATOR,
            "AND");
    if ("and".equalsIgnoreCase(sDefaultOperator)) {
        defaultOperator = QueryParser.Operator.AND;
    } else if ("or".equalsIgnoreCase(sDefaultOperator)) {
        defaultOperator = QueryParser.Operator.OR;
    } else {
        throw new ConfigurationException(
                "Defualt query string operator [" + sDefaultOperator + "] not recognized.");
    }
    if (log.isDebugEnabled()) {
        log.debug("Query Parser configured with allowLeadingWildcard [" + allowLeadingWildcard
                + "] and allowConstantScorePrefixQuery [" + allowConstantScorePrefixQuery + "]");
    }
}

From source file:org.easynet.resource.queryparser.QueryParserTestBase.java

License:Apache License

public void testWildcard() throws Exception {
    assertQueryEquals("term*", null, "term*");
    assertQueryEquals("term*^2", null, "term*^2.0");
    assertQueryEquals("term~", null, "term~2");
    assertQueryEquals("term~1", null, "term~1");
    assertQueryEquals("term~0.7", null, "term~1");
    assertQueryEquals("term~^3", null, "term~2^3.0");
    assertQueryEquals("term^3~", null, "term~2^3.0");
    assertQueryEquals("term*germ", null, "term*germ");
    assertQueryEquals("term*germ^3", null, "term*germ^3.0");

    assertTrue(getQuery("term*") instanceof PrefixQuery);
    assertTrue(getQuery("term*^2") instanceof PrefixQuery);
    assertTrue(getQuery("term~") instanceof FuzzyQuery);
    assertTrue(getQuery("term~0.7") instanceof FuzzyQuery);
    FuzzyQuery fq = (FuzzyQuery) getQuery("term~0.7");
    assertEquals(1, fq.getMaxEdits());//from www .  j  a va 2s.c o m
    assertEquals(FuzzyQuery.defaultPrefixLength, fq.getPrefixLength());
    fq = (FuzzyQuery) getQuery("term~");
    assertEquals(2, fq.getMaxEdits());
    assertEquals(FuzzyQuery.defaultPrefixLength, fq.getPrefixLength());

    assertParseException("term~1.1"); // value > 1, throws exception

    assertTrue(getQuery("term*germ") instanceof WildcardQuery);

    /*
     * Tests to see that wild card terms are (or are not) properly
     * lower-cased with propery parser configuration
     */
    // First prefix queries:
    // by default, convert to lowercase:
    assertWildcardQueryEquals("Term*", true, "term*");
    // explicitly set lowercase:
    assertWildcardQueryEquals("term*", true, "term*");
    assertWildcardQueryEquals("Term*", true, "term*");
    assertWildcardQueryEquals("TERM*", true, "term*");
    // explicitly disable lowercase conversion:
    assertWildcardQueryEquals("term*", false, "term*");
    assertWildcardQueryEquals("Term*", false, "Term*");
    assertWildcardQueryEquals("TERM*", false, "TERM*");
    // Then 'full' wildcard queries:
    // by default, convert to lowercase:
    assertWildcardQueryEquals("Te?m", "te?m");
    // explicitly set lowercase:
    assertWildcardQueryEquals("te?m", true, "te?m");
    assertWildcardQueryEquals("Te?m", true, "te?m");
    assertWildcardQueryEquals("TE?M", true, "te?m");
    assertWildcardQueryEquals("Te?m*gerM", true, "te?m*germ");
    // explicitly disable lowercase conversion:
    assertWildcardQueryEquals("te?m", false, "te?m");
    assertWildcardQueryEquals("Te?m", false, "Te?m");
    assertWildcardQueryEquals("TE?M", false, "TE?M");
    assertWildcardQueryEquals("Te?m*gerM", false, "Te?m*gerM");
    // Fuzzy queries:
    assertWildcardQueryEquals("Term~", "term~2");
    assertWildcardQueryEquals("Term~", true, "term~2");
    assertWildcardQueryEquals("Term~", false, "Term~2");
    // Range queries:
    assertWildcardQueryEquals("[A TO C]", "[a TO c]");
    assertWildcardQueryEquals("[A TO C]", true, "[a TO c]");
    assertWildcardQueryEquals("[A TO C]", false, "[A TO C]");
    // Test suffix queries: first disallow
    try {
        assertWildcardQueryEquals("*Term", true, "*term");
    } catch (Exception pe) {
        // expected exception
        if (!isQueryParserException(pe)) {
            fail();
        }
    }
    try {
        assertWildcardQueryEquals("?Term", true, "?term");
        fail();
    } catch (Exception pe) {
        // expected exception
        if (!isQueryParserException(pe)) {
            fail();
        }
    }
    // Test suffix queries: then allow
    assertWildcardQueryEquals("*Term", true, "*term", true);
    assertWildcardQueryEquals("?Term", true, "?term", true);
}

From source file:org.elasticsearch.index.query.FuzzyQueryParser.java

License:Apache License

@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
    XContentParser parser = parseContext.parser();

    XContentParser.Token token = parser.nextToken();
    if (token != XContentParser.Token.FIELD_NAME) {
        throw new QueryParsingException(parseContext.index(), "[fuzzy] query malformed, no field");
    }/*w  w w  .  ja v  a 2s.c om*/
    String fieldName = parser.currentName();

    String value = null;
    float boost = 1.0f;
    Fuzziness fuzziness = DEFAULT_FUZZINESS;
    int prefixLength = FuzzyQuery.defaultPrefixLength;
    int maxExpansions = FuzzyQuery.defaultMaxExpansions;
    boolean transpositions = false;
    String queryName = null;
    MultiTermQuery.RewriteMethod rewriteMethod = null;
    token = parser.nextToken();
    if (token == XContentParser.Token.START_OBJECT) {
        String currentFieldName = null;
        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
            if (token == XContentParser.Token.FIELD_NAME) {
                currentFieldName = parser.currentName();
            } else {
                if ("term".equals(currentFieldName)) {
                    value = parser.text();
                } else if ("value".equals(currentFieldName)) {
                    value = parser.text();
                } else if ("boost".equals(currentFieldName)) {
                    boost = parser.floatValue();
                } else if (FUZZINESS.match(currentFieldName, parseContext.parseFlags())) {
                    fuzziness = Fuzziness.parse(parser);
                } else if ("prefix_length".equals(currentFieldName)
                        || "prefixLength".equals(currentFieldName)) {
                    prefixLength = parser.intValue();
                } else if ("max_expansions".equals(currentFieldName)
                        || "maxExpansions".equals(currentFieldName)) {
                    maxExpansions = parser.intValue();
                } else if ("transpositions".equals(currentFieldName)) {
                    transpositions = parser.booleanValue();
                } else if ("rewrite".equals(currentFieldName)) {
                    rewriteMethod = QueryParsers.parseRewriteMethod(parser.textOrNull(), null);
                } else if ("_name".equals(currentFieldName)) {
                    queryName = parser.text();
                } else {
                    throw new QueryParsingException(parseContext.index(),
                            "[fuzzy] query does not support [" + currentFieldName + "]");
                }
            }
        }
        parser.nextToken();
    } else {
        value = parser.text();
        // move to the next token
        parser.nextToken();
    }

    if (value == null) {
        throw new QueryParsingException(parseContext.index(), "No value specified for fuzzy query");
    }

    Query query = null;
    MapperService.SmartNameFieldMappers smartNameFieldMappers = parseContext.smartFieldMappers(fieldName);
    if (smartNameFieldMappers != null) {
        if (smartNameFieldMappers.hasMapper()) {
            query = smartNameFieldMappers.mapper().fuzzyQuery(value, fuzziness, prefixLength, maxExpansions,
                    transpositions);
        }
    }
    if (query == null) {
        query = new FuzzyQuery(new Term(fieldName, value), fuzziness.asDistance(value), prefixLength,
                maxExpansions, transpositions);
    }
    if (query instanceof MultiTermQuery) {
        QueryParsers.setRewriteMethod((MultiTermQuery) query, rewriteMethod);
    }
    query.setBoost(boost);

    query = wrapSmartNameQuery(query, smartNameFieldMappers, parseContext);
    if (queryName != null) {
        parseContext.addNamedQuery(queryName, query);
    }
    return query;
}

From source file:org.elasticsearch.index.query.json.FieldJsonQueryParser.java

License:Apache License

@Override
public Query parse(JsonQueryParseContext parseContext) throws IOException, QueryParsingException {
    JsonParser jp = parseContext.jp();// ww  w .  jav  a2s  .  c om

    JsonToken token = jp.nextToken();
    assert token == JsonToken.FIELD_NAME;
    String fieldName = jp.getCurrentName();

    String queryString = null;
    float boost = 1.0f;
    MapperQueryParser.Operator defaultOperator = QueryParser.Operator.OR;
    boolean lowercaseExpandedTerms = true;
    boolean enablePositionIncrements = true;
    int phraseSlop = 0;
    float fuzzyMinSim = FuzzyQuery.defaultMinSimilarity;
    int fuzzyPrefixLength = FuzzyQuery.defaultPrefixLength;
    boolean escape = false;
    Analyzer analyzer = null;
    token = jp.nextToken();
    if (token == JsonToken.START_OBJECT) {
        String currentFieldName = null;
        while ((token = jp.nextToken()) != JsonToken.END_OBJECT) {
            if (token == JsonToken.FIELD_NAME) {
                currentFieldName = jp.getCurrentName();
            } else if (token == JsonToken.VALUE_STRING) {
                if ("query".equals(currentFieldName)) {
                    queryString = jp.getText();
                } else if ("boost".equals(currentFieldName)) {
                    boost = Float.parseFloat(jp.getText());
                } else if ("enable_position_increments".equals(currentFieldName)) {
                    enablePositionIncrements = Booleans.parseBoolean(jp.getText(), true);
                } else if ("lowercase_expanded_terms".equals(currentFieldName)) {
                    lowercaseExpandedTerms = Booleans.parseBoolean(jp.getText(), true);
                } else if ("phrase_slop".equals(currentFieldName)) {
                    phraseSlop = Integer.parseInt(jp.getText());
                } else if ("analyzer".equals(currentFieldName)) {
                    analyzer = analysisService.analyzer(jp.getText());
                } else if ("default_operator".equals(currentFieldName)) {
                    String op = jp.getText();
                    if ("or".equalsIgnoreCase(op)) {
                        defaultOperator = QueryParser.Operator.OR;
                    } else if ("and".equalsIgnoreCase(op)) {
                        defaultOperator = QueryParser.Operator.AND;
                    } else {
                        throw new QueryParsingException(index,
                                "Query default operator [" + op + "] is not allowed");
                    }
                } else if ("fuzzy_min_sim".equals(currentFieldName)) {
                    fuzzyMinSim = Float.parseFloat(jp.getText());
                } else if ("fuzzy_prefix_length".equals(currentFieldName)) {
                    fuzzyPrefixLength = Integer.parseInt(jp.getText());
                } else if ("escape".equals(currentFieldName)) {
                    escape = Booleans.parseBoolean(jp.getText(), false);
                }
            } else if (token == JsonToken.VALUE_NUMBER_INT) {
                if ("query".equals(currentFieldName)) {
                    queryString = jp.getText();
                } else if ("boost".equals(currentFieldName)) {
                    boost = jp.getIntValue();
                } else if ("enable_position_increments".equals(currentFieldName)) {
                    enablePositionIncrements = jp.getIntValue() != 0;
                } else if ("lowercase_expanded_terms".equals(currentFieldName)) {
                    lowercaseExpandedTerms = jp.getIntValue() != 0;
                } else if ("phrase_slop".equals(currentFieldName)) {
                    phraseSlop = jp.getIntValue();
                } else if ("fuzzy_min_sim".equals(currentFieldName)) {
                    fuzzyMinSim = jp.getIntValue();
                } else if ("fuzzy_prefix_length".equals(currentFieldName)) {
                    fuzzyPrefixLength = jp.getIntValue();
                } else if ("escape".equals(currentFieldName)) {
                    escape = jp.getIntValue() != 0;
                }
            } else if (token == JsonToken.VALUE_NUMBER_FLOAT) {
                if ("query".equals(currentFieldName)) {
                    queryString = jp.getText();
                } else if ("boost".equals(currentFieldName)) {
                    boost = jp.getFloatValue();
                } else if ("fuzzy_prefix_length".equals(currentFieldName)) {
                    fuzzyPrefixLength = jp.getIntValue();
                }
            } else if (token == JsonToken.VALUE_TRUE) {
                if ("query".equals(currentFieldName)) {
                    queryString = jp.getText();
                } else if ("enable_position_increments".equals(currentFieldName)) {
                    enablePositionIncrements = true;
                } else if ("lowercase_expanded_terms".equals(currentFieldName)) {
                    lowercaseExpandedTerms = true;
                } else if ("escape".equals(currentFieldName)) {
                    escape = true;
                }
            } else if (token == JsonToken.VALUE_FALSE) {
                if ("query".equals(currentFieldName)) {
                    queryString = jp.getText();
                } else if ("enable_position_increments".equals(currentFieldName)) {
                    enablePositionIncrements = false;
                } else if ("lowercase_expanded_terms".equals(currentFieldName)) {
                    lowercaseExpandedTerms = false;
                } else if ("escape".equals(currentFieldName)) {
                    escape = false;
                }
            }
        }
        jp.nextToken();
    } else {
        queryString = jp.getText();
        // move to the next token
        jp.nextToken();
    }

    if (analyzer == null) {
        analyzer = parseContext.mapperService().searchAnalyzer();
    }

    if (queryString == null) {
        throw new QueryParsingException(index, "No value specified for term query");
    }

    MapperQueryParser queryParser = new MapperQueryParser(fieldName, analyzer, parseContext.mapperService(),
            parseContext.indexCache());
    queryParser.setEnablePositionIncrements(enablePositionIncrements);
    queryParser.setLowercaseExpandedTerms(lowercaseExpandedTerms);
    queryParser.setPhraseSlop(phraseSlop);
    queryParser.setDefaultOperator(defaultOperator);
    queryParser.setFuzzyMinSim(fuzzyMinSim);
    queryParser.setFuzzyPrefixLength(fuzzyPrefixLength);

    if (escape) {
        queryString = QueryParser.escape(queryString);
    }

    try {
        Query query = queryParser.parse(queryString);
        query.setBoost(boost);
        return optimizeQuery(fixNegativeQueryIfNeeded(query));
    } catch (ParseException e) {
        throw new QueryParsingException(index, "Failed to parse query [" + queryString + "]", e);
    }
}

From source file:org.elasticsearch.index.query.json.QueryStringJsonQueryParser.java

License:Apache License

@Override
public Query parse(JsonQueryParseContext parseContext) throws IOException, QueryParsingException {
    JsonParser jp = parseContext.jp();/*from   www.  ja  va  2  s . c o m*/

    // move to the field value

    String queryString = null;
    String defaultField = AllFieldMapper.NAME; // default to all
    MapperQueryParser.Operator defaultOperator = QueryParser.Operator.OR;
    boolean allowLeadingWildcard = true;
    boolean lowercaseExpandedTerms = true;
    boolean enablePositionIncrements = true;
    float fuzzyMinSim = FuzzyQuery.defaultMinSimilarity;
    int fuzzyPrefixLength = FuzzyQuery.defaultPrefixLength;
    int phraseSlop = 0;
    float boost = 1.0f;
    boolean escape = false;
    Analyzer analyzer = null;
    List<String> fields = null;
    ExtTObjectFloatHashMap<String> boosts = null;
    float tieBreaker = 0.0f;
    boolean useDisMax = true;

    String currentFieldName = null;
    JsonToken token;
    while ((token = jp.nextToken()) != JsonToken.END_OBJECT) {
        if (token == JsonToken.FIELD_NAME) {
            currentFieldName = jp.getCurrentName();
        } else if (token == JsonToken.START_ARRAY) {
            if ("fields".equals(currentFieldName)) {
                while ((token = jp.nextToken()) != JsonToken.END_ARRAY) {
                    String fField = null;
                    float fBoost = -1;
                    char[] text = jp.getTextCharacters();
                    int end = jp.getTextOffset() + jp.getTextLength();
                    for (int i = jp.getTextOffset(); i < end; i++) {
                        if (text[i] == '^') {
                            int relativeLocation = i - jp.getTextOffset();
                            fField = new String(text, jp.getTextOffset(), relativeLocation);
                            fBoost = Float.parseFloat(
                                    new String(text, i + 1, jp.getTextLength() - relativeLocation - 1));
                            break;
                        }
                    }
                    if (fField == null) {
                        fField = jp.getText();
                    }
                    if (fields == null) {
                        fields = Lists.newArrayList();
                    }
                    fields.add(fField);
                    if (fBoost != -1) {
                        if (boosts == null) {
                            boosts = new ExtTObjectFloatHashMap<String>();
                        }
                        boosts.put(fField, fBoost);
                    }
                }
            }
        } else if (token == JsonToken.VALUE_STRING) {
            if ("query".equals(currentFieldName)) {
                queryString = jp.getText();
            } else if ("default_field".equals(currentFieldName)) {
                defaultField = parseContext.indexName(jp.getText());
            } else if ("default_operator".equals(currentFieldName)) {
                String op = jp.getText();
                if ("or".equalsIgnoreCase(op)) {
                    defaultOperator = QueryParser.Operator.OR;
                } else if ("and".equalsIgnoreCase(op)) {
                    defaultOperator = QueryParser.Operator.AND;
                } else {
                    throw new QueryParsingException(index,
                            "Query default operator [" + op + "] is not allowed");
                }
            } else if ("analyzer".equals(currentFieldName)) {
                analyzer = analysisService.analyzer(jp.getText());
            } else if ("allow_leading_wildcard".equals(currentFieldName)) {
                allowLeadingWildcard = Booleans.parseBoolean(jp.getText(), false);
            } else if ("lowercase_expanded_terms".equals(currentFieldName)) {
                lowercaseExpandedTerms = Booleans.parseBoolean(jp.getText(), false);
            } else if ("enable_position_increments".equals(currentFieldName)) {
                enablePositionIncrements = Booleans.parseBoolean(jp.getText(), false);
            } else if ("escape".equals(currentFieldName)) {
                escape = Booleans.parseBoolean(jp.getText(), false);
            } else if ("use_dis_max".equals(currentFieldName)) {
                useDisMax = Booleans.parseBoolean(jp.getText(), false);
            } else if ("fuzzy_prefix_length".equals(currentFieldName)) {
                fuzzyPrefixLength = Integer.parseInt(jp.getText());
            } else if ("phrase_slop".equals(currentFieldName)) {
                phraseSlop = Integer.parseInt(jp.getText());
            } else if ("fuzzy_min_sim".equals(currentFieldName)) {
                fuzzyMinSim = Float.parseFloat(jp.getText());
            } else if ("boost".equals(currentFieldName)) {
                boost = Float.parseFloat(jp.getText());
            } else if ("tie_breaker".equals(currentFieldName)) {
                tieBreaker = Float.parseFloat(jp.getText());
            }
        } else if (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE) {
            if ("allow_leading_wildcard".equals(currentFieldName)) {
                allowLeadingWildcard = token == JsonToken.VALUE_TRUE;
            } else if ("lowercase_expanded_terms".equals(currentFieldName)) {
                lowercaseExpandedTerms = token == JsonToken.VALUE_TRUE;
            } else if ("enable_position_increments".equals(currentFieldName)) {
                enablePositionIncrements = token == JsonToken.VALUE_TRUE;
            } else if ("escape".equals(currentFieldName)) {
                escape = token == JsonToken.VALUE_TRUE;
            } else if ("use_dis_max".equals(currentFieldName)) {
                useDisMax = token == JsonToken.VALUE_TRUE;
            }
        } else if (token == JsonToken.VALUE_NUMBER_FLOAT) {
            if ("fuzzy_min_sim".equals(currentFieldName)) {
                fuzzyMinSim = jp.getFloatValue();
            } else if ("boost".equals(currentFieldName)) {
                boost = jp.getFloatValue();
            } else if ("tie_breaker".equals(currentFieldName)) {
                tieBreaker = jp.getFloatValue();
            }
        } else if (token == JsonToken.VALUE_NUMBER_INT) {
            if ("fuzzy_prefix_length".equals(currentFieldName)) {
                fuzzyPrefixLength = jp.getIntValue();
            } else if ("phrase_slop".equals(currentFieldName)) {
                phraseSlop = jp.getIntValue();
            } else if ("fuzzy_min_sim".equals(currentFieldName)) {
                fuzzyMinSim = jp.getFloatValue();
            } else if ("boost".equals(currentFieldName)) {
                boost = jp.getFloatValue();
            } else if ("allow_leading_wildcard".equals(currentFieldName)) {
                allowLeadingWildcard = jp.getIntValue() != 0;
            } else if ("lowercase_expanded_terms".equals(currentFieldName)) {
                lowercaseExpandedTerms = jp.getIntValue() != 0;
            } else if ("enable_position_increments".equals(currentFieldName)) {
                enablePositionIncrements = jp.getIntValue() != 0;
            } else if ("escape".equals(currentFieldName)) {
                escape = jp.getIntValue() != 0;
            } else if ("use_dis_max".equals(currentFieldName)) {
                useDisMax = jp.getIntValue() != 0;
            } else if ("tie_breaker".equals(currentFieldName)) {
                tieBreaker = jp.getFloatValue();
            }
        }
    }
    if (queryString == null) {
        throw new QueryParsingException(index, "query_string must be provided with a [query]");
    }
    if (analyzer == null) {
        analyzer = parseContext.mapperService().searchAnalyzer();
    }

    MapperQueryParser queryParser;
    if (fields != null) {
        if (fields.size() == 1) {
            queryParser = new MapperQueryParser(fields.get(0), analyzer, parseContext.mapperService(),
                    parseContext.indexCache());
        } else {
            MultiFieldMapperQueryParser mQueryParser = new MultiFieldMapperQueryParser(fields, boosts, analyzer,
                    parseContext.mapperService(), parseContext.indexCache());
            mQueryParser.setTieBreaker(tieBreaker);
            mQueryParser.setUseDisMax(useDisMax);
            queryParser = mQueryParser;
        }
    } else {
        queryParser = new MapperQueryParser(defaultField, analyzer, parseContext.mapperService(),
                parseContext.indexCache());
    }
    queryParser.setEnablePositionIncrements(enablePositionIncrements);
    queryParser.setLowercaseExpandedTerms(lowercaseExpandedTerms);
    queryParser.setAllowLeadingWildcard(allowLeadingWildcard);
    queryParser.setDefaultOperator(defaultOperator);
    queryParser.setFuzzyMinSim(fuzzyMinSim);
    queryParser.setFuzzyPrefixLength(fuzzyPrefixLength);
    queryParser.setPhraseSlop(phraseSlop);

    if (escape) {
        queryString = QueryParser.escape(queryString);
    }

    try {
        Query query = queryParser.parse(queryString);
        query.setBoost(boost);
        return optimizeQuery(fixNegativeQueryIfNeeded(query));
    } catch (ParseException e) {
        throw new QueryParsingException(index, "Failed to parse query [" + queryString + "]", e);
    }
}

From source file:org.elasticsearch.index.query.MatchQueryBuilder.java

License:Apache License

public static Optional<MatchQueryBuilder> fromXContent(QueryParseContext parseContext) throws IOException {
    XContentParser parser = parseContext.parser();
    String fieldName = null;/*from   ww  w .  j  a v a 2 s.co m*/
    MatchQuery.Type type = MatchQuery.Type.BOOLEAN;
    Object value = null;
    float boost = AbstractQueryBuilder.DEFAULT_BOOST;
    String minimumShouldMatch = null;
    String analyzer = null;
    Operator operator = MatchQueryBuilder.DEFAULT_OPERATOR;
    int slop = MatchQuery.DEFAULT_PHRASE_SLOP;
    Fuzziness fuzziness = null;
    int prefixLength = FuzzyQuery.defaultPrefixLength;
    int maxExpansion = FuzzyQuery.defaultMaxExpansions;
    boolean fuzzyTranspositions = FuzzyQuery.defaultTranspositions;
    String fuzzyRewrite = null;
    boolean lenient = MatchQuery.DEFAULT_LENIENCY;
    Float cutOffFrequency = null;
    ZeroTermsQuery zeroTermsQuery = MatchQuery.DEFAULT_ZERO_TERMS_QUERY;
    String queryName = null;
    String currentFieldName = null;
    XContentParser.Token token;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (parseContext.isDeprecatedSetting(currentFieldName)) {
            // skip
        } else if (token == XContentParser.Token.START_OBJECT) {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName, currentFieldName);
            fieldName = currentFieldName;
            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                } else if (token.isValue()) {
                    if (parseContext.getParseFieldMatcher().match(currentFieldName, QUERY_FIELD)) {
                        value = parser.objectText();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName, TYPE_FIELD)) {
                        String tStr = parser.text();
                        if ("boolean".equals(tStr)) {
                            type = MatchQuery.Type.BOOLEAN;
                        } else if ("phrase".equals(tStr)) {
                            type = MatchQuery.Type.PHRASE;
                        } else if ("phrase_prefix".equals(tStr) || ("phrasePrefix".equals(tStr))) {
                            type = MatchQuery.Type.PHRASE_PREFIX;
                        } else {
                            throw new ParsingException(parser.getTokenLocation(),
                                    "[" + NAME + "] query does not support type " + tStr);
                        }
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName, ANALYZER_FIELD)) {
                        analyzer = parser.text();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName,
                            AbstractQueryBuilder.BOOST_FIELD)) {
                        boost = parser.floatValue();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName, SLOP_FIELD)) {
                        slop = parser.intValue();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName, Fuzziness.FIELD)) {
                        fuzziness = Fuzziness.parse(parser);
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName,
                            PREFIX_LENGTH_FIELD)) {
                        prefixLength = parser.intValue();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName,
                            MAX_EXPANSIONS_FIELD)) {
                        maxExpansion = parser.intValue();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName, OPERATOR_FIELD)) {
                        operator = Operator.fromString(parser.text());
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName,
                            MINIMUM_SHOULD_MATCH_FIELD)) {
                        minimumShouldMatch = parser.textOrNull();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName,
                            FUZZY_REWRITE_FIELD)) {
                        fuzzyRewrite = parser.textOrNull();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName,
                            FUZZY_TRANSPOSITIONS_FIELD)) {
                        fuzzyTranspositions = parser.booleanValue();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName, LENIENT_FIELD)) {
                        lenient = parser.booleanValue();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName,
                            CUTOFF_FREQUENCY_FIELD)) {
                        cutOffFrequency = parser.floatValue();
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName,
                            ZERO_TERMS_QUERY_FIELD)) {
                        String zeroTermsDocs = parser.text();
                        if ("none".equalsIgnoreCase(zeroTermsDocs)) {
                            zeroTermsQuery = MatchQuery.ZeroTermsQuery.NONE;
                        } else if ("all".equalsIgnoreCase(zeroTermsDocs)) {
                            zeroTermsQuery = MatchQuery.ZeroTermsQuery.ALL;
                        } else {
                            throw new ParsingException(parser.getTokenLocation(),
                                    "Unsupported zero_terms_docs value [" + zeroTermsDocs + "]");
                        }
                    } else if (parseContext.getParseFieldMatcher().match(currentFieldName,
                            AbstractQueryBuilder.NAME_FIELD)) {
                        queryName = parser.text();
                    } else {
                        throw new ParsingException(parser.getTokenLocation(),
                                "[" + NAME + "] query does not support [" + currentFieldName + "]");
                    }
                } else {
                    throw new ParsingException(parser.getTokenLocation(),
                            "[" + NAME + "] unknown token [" + token + "] after [" + currentFieldName + "]");
                }
            }
        } else {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName,
                    parser.currentName());
            fieldName = parser.currentName();
            value = parser.objectText();
        }
    }

    if (value == null) {
        throw new ParsingException(parser.getTokenLocation(), "No text specified for text query");
    }

    MatchQueryBuilder matchQuery = new MatchQueryBuilder(fieldName, value);
    matchQuery.operator(operator);
    matchQuery.type(type);
    matchQuery.analyzer(analyzer);
    matchQuery.slop(slop);
    matchQuery.minimumShouldMatch(minimumShouldMatch);
    if (fuzziness != null) {
        matchQuery.fuzziness(fuzziness);
    }
    matchQuery.fuzzyRewrite(fuzzyRewrite);
    matchQuery.prefixLength(prefixLength);
    matchQuery.fuzzyTranspositions(fuzzyTranspositions);
    matchQuery.maxExpansions(maxExpansion);
    matchQuery.lenient(lenient);
    if (cutOffFrequency != null) {
        matchQuery.cutoffFrequency(cutOffFrequency);
    }
    matchQuery.zeroTermsQuery(zeroTermsQuery);
    matchQuery.queryName(queryName);
    matchQuery.boost(boost);
    return Optional.of(matchQuery);
}

From source file:org.elasticsearch.index.query.TextQueryParser.java

License:Apache License

@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
    XContentParser parser = parseContext.parser();

    org.elasticsearch.index.search.TextQueryParser.Type type = org.elasticsearch.index.search.TextQueryParser.Type.BOOLEAN;
    if ("text_phrase".equals(parser.currentName()) || "textPhrase".equals(parser.currentName())) {
        type = org.elasticsearch.index.search.TextQueryParser.Type.PHRASE;
    } else if ("text_phrase_prefix".equals(parser.currentName())
            || "textPhrasePrefix".equals(parser.currentName())) {
        type = org.elasticsearch.index.search.TextQueryParser.Type.PHRASE_PREFIX;
    }/*from  ww w  .  j  a v a2 s  . c  o  m*/

    XContentParser.Token token = parser.nextToken();
    assert token == XContentParser.Token.FIELD_NAME;
    String fieldName = parser.currentName();

    String text = null;
    float boost = 1.0f;
    int phraseSlop = 0;
    String analyzer = null;
    String fuzziness = null;
    int prefixLength = FuzzyQuery.defaultPrefixLength;
    int maxExpansions = FuzzyQuery.defaultMaxExpansions;
    BooleanClause.Occur occur = BooleanClause.Occur.SHOULD;

    token = parser.nextToken();
    if (token == XContentParser.Token.START_OBJECT) {
        String currentFieldName = null;
        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
            if (token == XContentParser.Token.FIELD_NAME) {
                currentFieldName = parser.currentName();
            } else if (token.isValue()) {
                if ("query".equals(currentFieldName)) {
                    text = parser.text();
                } else if ("type".equals(currentFieldName)) {
                    String tStr = parser.text();
                    if ("boolean".equals(tStr)) {
                        type = org.elasticsearch.index.search.TextQueryParser.Type.BOOLEAN;
                    } else if ("phrase".equals(tStr)) {
                        type = org.elasticsearch.index.search.TextQueryParser.Type.PHRASE;
                    } else if ("phrase_prefix".equals(tStr) || "phrasePrefix".equals(currentFieldName)) {
                        type = org.elasticsearch.index.search.TextQueryParser.Type.PHRASE_PREFIX;
                    }
                } else if ("analyzer".equals(currentFieldName)) {
                    analyzer = parser.textOrNull();
                } else if ("boost".equals(currentFieldName)) {
                    boost = parser.floatValue();
                } else if ("slop".equals(currentFieldName) || "phrase_slop".equals(currentFieldName)
                        || "phraseSlop".equals(currentFieldName)) {
                    phraseSlop = parser.intValue();
                } else if ("fuzziness".equals(currentFieldName)) {
                    fuzziness = parser.textOrNull();
                } else if ("prefix_length".equals(currentFieldName)
                        || "prefixLength".equals(currentFieldName)) {
                    prefixLength = parser.intValue();
                } else if ("max_expansions".equals(currentFieldName)
                        || "maxExpansions".equals(currentFieldName)) {
                    maxExpansions = parser.intValue();
                } else if ("operator".equals(currentFieldName)) {
                    String op = parser.text();
                    if ("or".equalsIgnoreCase(op)) {
                        occur = BooleanClause.Occur.SHOULD;
                    } else if ("and".equalsIgnoreCase(op)) {
                        occur = BooleanClause.Occur.MUST;
                    } else {
                        throw new QueryParsingException(parseContext.index(),
                                "text query requires operator to be either 'and' or 'or', not [" + op + "]");
                    }
                }
            }
        }
        parser.nextToken();
    } else {
        text = parser.text();
        // move to the next token
        parser.nextToken();
    }

    if (text == null) {
        throw new QueryParsingException(parseContext.index(), "No text specified for text query");
    }

    org.elasticsearch.index.search.TextQueryParser tQP = new org.elasticsearch.index.search.TextQueryParser(
            parseContext, fieldName, text);
    tQP.setPhraseSlop(phraseSlop);
    tQP.setAnalyzer(analyzer);
    tQP.setFuzziness(fuzziness);
    tQP.setFuzzyPrefixLength(prefixLength);
    tQP.setMaxExpansions(maxExpansions);
    tQP.setOccur(occur);

    Query query = tQP.parse(type);
    query.setBoost(boost);
    return query;
}

From source file:org.elasticsearch.index.query.xcontent.FuzzyQueryParser.java

License:Apache License

@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
    XContentParser parser = parseContext.parser();

    XContentParser.Token token = parser.nextToken();
    assert token == XContentParser.Token.FIELD_NAME;
    String fieldName = parser.currentName();

    String value = null;//from w ww  .ja v a 2 s  .  c o  m
    float boost = 1.0f;
    String minSimilarity = "0.5";
    int prefixLength = FuzzyQuery.defaultPrefixLength;
    int maxExpansions = FuzzyQuery.defaultMaxExpansions;
    token = parser.nextToken();
    if (token == XContentParser.Token.START_OBJECT) {
        String currentFieldName = null;
        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
            if (token == XContentParser.Token.FIELD_NAME) {
                currentFieldName = parser.currentName();
            } else {
                if ("term".equals(currentFieldName)) {
                    value = parser.text();
                } else if ("value".equals(currentFieldName)) {
                    value = parser.text();
                } else if ("boost".equals(currentFieldName)) {
                    boost = parser.floatValue();
                } else if ("min_similarity".equals(currentFieldName)
                        || "minSimilarity".equals(currentFieldName)) {
                    minSimilarity = parser.text();
                } else if ("prefix_length".equals(currentFieldName)
                        || "prefixLength".equals(currentFieldName)) {
                    prefixLength = parser.intValue();
                } else if ("max_expansions".equals(currentFieldName)
                        || "maxExpansions".equals(currentFieldName)) {
                    maxExpansions = parser.intValue();
                }
            }
        }
        parser.nextToken();
    } else {
        value = parser.text();
        // move to the next token
        parser.nextToken();
    }

    if (value == null) {
        throw new QueryParsingException(index, "No value specified for fuzzy query");
    }

    Query query = null;
    MapperService.SmartNameFieldMappers smartNameFieldMappers = parseContext.smartFieldMappers(fieldName);
    if (smartNameFieldMappers != null) {
        if (smartNameFieldMappers.hasMapper()) {
            query = smartNameFieldMappers.mapper().fuzzyQuery(value, minSimilarity, prefixLength,
                    maxExpansions);
        }
    }
    if (query == null) {
        query = new FuzzyQuery(new Term(fieldName, value), Float.parseFloat(minSimilarity), prefixLength,
                maxExpansions);
    }
    query.setBoost(boost);

    return wrapSmartNameQuery(query, smartNameFieldMappers, parseContext);
}