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

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

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

Introduction

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

Prototype

float defaultMinSimilarity

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

Click Source Link

Usage

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.  ja v a2s .c om
            .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.elasticsearch.index.query.json.FieldJsonQueryParser.java

License:Apache License

@Override
public Query parse(JsonQueryParseContext parseContext) throws IOException, QueryParsingException {
    JsonParser jp = parseContext.jp();/*  w w w  . j av  a  2 s.co  m*/

    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();/*  w ww .j av a2  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);
    }
}