Examples with Query org.apache.lucene.search.Query used on opensource projects

Example 11 with Query

use of org.apache.lucene.search.Query in project elasticsearch by elastic.

the class MatchQuery method blendTermQuery.

protected Query blendTermQuery(Term term, MappedFieldType fieldType) {
    if (fuzziness != null) {
        if (fieldType != null) {
            try {
                Query query = fieldType.fuzzyQuery(term.text(), fuzziness, fuzzyPrefixLength, maxExpansions, transpositions);
                if (query instanceof FuzzyQuery) {
                    QueryParsers.setRewriteMethod((FuzzyQuery) query, fuzzyRewriteMethod);
                }
                return query;
            } catch (RuntimeException e) {
                if (lenient) {
                    return new TermQuery(term);
                } else {
                    throw e;
                }
            }
        }
        int edits = fuzziness.asDistance(term.text());
        FuzzyQuery query = new FuzzyQuery(term, edits, fuzzyPrefixLength, maxExpansions, transpositions);
        QueryParsers.setRewriteMethod(query, fuzzyRewriteMethod);
        return query;
    }
    if (fieldType != null) {
        Query query = termQuery(fieldType, term.bytes(), lenient);
        if (query != null) {
            return query;
        }
    }
    return new TermQuery(term);
}

Example 12 with Query

use of org.apache.lucene.search.Query in project elasticsearch by elastic.

the class MultiMatchQuery method parseAndApply.

private Query parseAndApply(Type type, String fieldName, Object value, String minimumShouldMatch, Float boostValue) throws IOException {
    Query query = parse(type, fieldName, value);
    query = Queries.maybeApplyMinimumShouldMatch(query, minimumShouldMatch);
    if (query != null && boostValue != null && boostValue != AbstractQueryBuilder.DEFAULT_BOOST) {
        query = new BoostQuery(query, boostValue);
    }
    return query;
}

Example 13 with Query

use of org.apache.lucene.search.Query in project elasticsearch by elastic.

the class MultiMatchQuery method parse.

public Query parse(MultiMatchQueryBuilder.Type type, Map<String, Float> fieldNames, Object value, String minimumShouldMatch) throws IOException {
    Query result;
    if (fieldNames.size() == 1) {
        Map.Entry<String, Float> fieldBoost = fieldNames.entrySet().iterator().next();
        Float boostValue = fieldBoost.getValue();
        result = parseAndApply(type.matchQueryType(), fieldBoost.getKey(), value, minimumShouldMatch, boostValue);
    } else {
        final float tieBreaker = groupTieBreaker == null ? type.tieBreaker() : groupTieBreaker;
        switch(type) {
            case PHRASE:
            case PHRASE_PREFIX:
            case BEST_FIELDS:
            case MOST_FIELDS:
                queryBuilder = new QueryBuilder(tieBreaker);
                break;
            case CROSS_FIELDS:
                queryBuilder = new CrossFieldsQueryBuilder(tieBreaker);
                break;
            default:
                throw new IllegalStateException("No such type: " + type);
        }
        final List<? extends Query> queries = queryBuilder.buildGroupedQueries(type, fieldNames, value, minimumShouldMatch);
        result = queryBuilder.combineGrouped(queries);
    }
    assert result != null;
    return result;
}

Example 14 with Query

use of org.apache.lucene.search.Query in project elasticsearch by elastic.

the class SimpleQueryParser method newFuzzyQuery.

/**
     * Dispatches to Lucene's SimpleQueryParser's newFuzzyQuery, optionally
     * lowercasing the term first
     */
@Override
public Query newFuzzyQuery(String text, int fuzziness) {
    BooleanQuery.Builder bq = new BooleanQuery.Builder();
    bq.setDisableCoord(true);
    for (Map.Entry<String, Float> entry : weights.entrySet()) {
        final String fieldName = entry.getKey();
        try {
            final BytesRef term = getAnalyzer().normalize(fieldName, text);
            Query query = new FuzzyQuery(new Term(fieldName, term), fuzziness);
            bq.add(wrapWithBoost(query, entry.getValue()), BooleanClause.Occur.SHOULD);
        } catch (RuntimeException e) {
            rethrowUnlessLenient(e);
        }
    }
    return super.simplify(bq.build());
}

Example 15 with Query

use of org.apache.lucene.search.Query in project elasticsearch by elastic.

the class SimpleQueryStringBuilder method doToQuery.

@Override
protected Query doToQuery(QueryShardContext context) throws IOException {
    // field names in builder can have wildcards etc, need to resolve them here
    Map<String, Float> resolvedFieldsAndWeights = new TreeMap<>();
    if ((useAllFields != null && useAllFields) && (fieldsAndWeights.size() != 0)) {
        throw addValidationError("cannot use [all_fields] parameter in conjunction with [fields]", null);
    }
    // If explicitly required to use all fields, use all fields, OR:
    // Automatically determine the fields (to replace the _all field) if all of the following are true:
    // - The _all field is disabled,
    // - and the default_field has not been changed in the settings
    // - and no fields are specified in the request
    Settings newSettings = new Settings(settings);
    if ((this.useAllFields != null && this.useAllFields) || (context.getMapperService().allEnabled() == false && "_all".equals(context.defaultField()) && this.fieldsAndWeights.isEmpty())) {
        resolvedFieldsAndWeights = QueryStringQueryBuilder.allQueryableDefaultFields(context);
        // Need to use lenient mode when using "all-mode" so exceptions aren't thrown due to mismatched types
        newSettings.lenient(lenientSet ? settings.lenient() : true);
    } else {
        // Use the default field if no fields specified
        if (fieldsAndWeights.isEmpty()) {
            resolvedFieldsAndWeights.put(resolveIndexName(context.defaultField(), context), AbstractQueryBuilder.DEFAULT_BOOST);
        } else {
            for (Map.Entry<String, Float> fieldEntry : fieldsAndWeights.entrySet()) {
                if (Regex.isSimpleMatchPattern(fieldEntry.getKey())) {
                    for (String fieldName : context.getMapperService().simpleMatchToIndexNames(fieldEntry.getKey())) {
                        resolvedFieldsAndWeights.put(fieldName, fieldEntry.getValue());
                    }
                } else {
                    resolvedFieldsAndWeights.put(resolveIndexName(fieldEntry.getKey(), context), fieldEntry.getValue());
                }
            }
        }
    }
    // Use standard analyzer by default if none specified
    Analyzer luceneAnalyzer;
    if (analyzer == null) {
        luceneAnalyzer = context.getMapperService().searchAnalyzer();
    } else {
        luceneAnalyzer = context.getIndexAnalyzers().get(analyzer);
        if (luceneAnalyzer == null) {
            throw new QueryShardException(context, "[" + SimpleQueryStringBuilder.NAME + "] analyzer [" + analyzer + "] not found");
        }
    }
    SimpleQueryParser sqp = new SimpleQueryParser(luceneAnalyzer, resolvedFieldsAndWeights, flags, newSettings, context);
    sqp.setDefaultOperator(defaultOperator.toBooleanClauseOccur());
    Query query = sqp.parse(queryText);
    return Queries.maybeApplyMinimumShouldMatch(query, minimumShouldMatch);
}