/** * Create a fuzzy query * * @param path path * @param value value to match * @param maxEdits must be >= 0 and <= {@link LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE}. * @return condition */ public static BooleanExpression fuzzyLike(Path<String> path, String value, int maxEdits) { Term term = new Term(path.getMetadata().getName(), value); return new QueryElement(new FuzzyQuery(term, maxEdits)); }
/** * Create a fuzzy query * * @param path path * @param value value to match * @return condition */ public static BooleanExpression fuzzyLike(Path<String> path, String value) { Term term = new Term(path.getMetadata().getName(), value); return new QueryElement(new FuzzyQuery(term)); }
/** * Create a fuzzy query * * @param path path * @param value value to match * @return condition */ public static BooleanExpression fuzzyLike(Path<String> path, String value) { Term term = new Term(path.getMetadata().getName(), value); return new QueryElement(new FuzzyQuery(term)); }
/** * Create a fuzzy query * * @param path path * @param value value to match * @param minimumSimilarity a value between 0 and 1 to set the required similarity * @return condition */ public static BooleanExpression fuzzyLike(Path<String> path, String value, float minimumSimilarity) { Term term = new Term(path.getMetadata().getName(), value); return new QueryElement(new FuzzyQuery(term, minimumSimilarity)); }
/** * Create a fuzzy query * * @param path path * @param value value to match * @param minimumSimilarity a value between 0 and 1 to set the required similarity * @param prefixLength length of common (non-fuzzy) prefix * @return condition */ public static BooleanExpression fuzzyLike(Path<String> path, String value, float minimumSimilarity, int prefixLength) { Term term = new Term(path.getMetadata().getName(), value); return new QueryElement(new FuzzyQuery(term, minimumSimilarity, prefixLength)); }
/** * Create a fuzzy query * * @param path * path * @param value * value to match * @return condition */ public static BooleanExpression fuzzyLike(Path<String> path, String value) { Term term = new Term(path.getMetadata().getName(), value); return new QueryElement(new FuzzyQuery(term)); }
/** * Create a fuzzy query * * @param path path * @param value value to match * @param maxEdits must be >= 0 and <= {@link LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE}. * @param prefixLength length of common (non-fuzzy) prefix * @return condition */ public static BooleanExpression fuzzyLike(Path<String> path, String value, int maxEdits, int prefixLength) { Term term = new Term(path.getMetadata().getName(), value); return new QueryElement(new FuzzyQuery(term, maxEdits, prefixLength)); }
/** * Create a fuzzy query * * @param path * path * @param value * value to match * @param maxEdits * must be >= 0 and <= * {@link LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE}. * @return condition */ public static BooleanExpression fuzzyLike(Path<String> path, String value, int maxEdits) { Term term = new Term(path.getMetadata().getName(), value); return new QueryElement(new FuzzyQuery(term, maxEdits)); }
/** * Create a fuzzy query * * @param path * path * @param value * value to match * @param maxEdits * must be >= 0 and <= * {@link LevenshteinAutomata#MAXIMUM_SUPPORTED_DISTANCE}. * @param prefixLength * length of common (non-fuzzy) prefix * @return condition */ public static BooleanExpression fuzzyLike(Path<String> path, String value, int maxEdits, int prefixLength) { Term term = new Term(path.getMetadata().getName(), value); return new QueryElement(new FuzzyQuery(term, maxEdits, prefixLength)); }
termQuery.add(new FuzzyQuery(new Term("name", token)), BooleanClause.Occur.SHOULD);
@Override public Query fuzzyQuery(Object value, Fuzziness fuzziness, int prefixLength, int maxExpansions, boolean transpositions) { failIfNotIndexed(); return new FuzzyQuery(new Term(name(), indexedValueForSearch(value)), fuzziness.asDistance(BytesRefs.toString(value)), prefixLength, maxExpansions, transpositions); }
@Override protected Query newFuzzyQuery(Term term, float minimumSimilarity, int prefixLength) { int numEdits = Fuzziness.build(minimumSimilarity).asDistance(term.text()); FuzzyQuery query = new FuzzyQuery(term, numEdits, prefixLength, fuzzyMaxExpansions, fuzzyTranspositions); QueryParsers.setRewriteMethod(query, fuzzyRewriteMethod); return query; }
Query termQuery; if (fuzzy_search && isFuzzy(fieldName)) termQuery = new FuzzyQuery(new Term(fieldName, term)); else termQuery = new TermQuery(new Term(fieldName, term));
@Override protected Query doToQuery(QueryShardContext context) throws IOException { Query query = null; String rewrite = this.rewrite; if (rewrite == null && context.isFilter()) { rewrite = QueryParsers.CONSTANT_SCORE.getPreferredName(); } MappedFieldType fieldType = context.fieldMapper(fieldName); if (fieldType != null) { query = fieldType.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions); } if (query == null) { int maxEdits = fuzziness.asDistance(BytesRefs.toString(value)); query = new FuzzyQuery(new Term(fieldName, BytesRefs.toBytesRef(value)), maxEdits, prefixLength, maxExpansions, transpositions); } if (query instanceof MultiTermQuery) { MultiTermQuery.RewriteMethod rewriteMethod = QueryParsers.parseRewriteMethod(rewrite, null, LoggingDeprecationHandler.INSTANCE); QueryParsers.setRewriteMethod((MultiTermQuery) query, rewriteMethod); } return query; }
/** * Builds a new FuzzyQuery instance * @param term Term * @param minimumSimilarity minimum similarity * @param prefixLength prefix length * @return new FuzzyQuery Instance */ protected Query newFuzzyQuery(Term term, float minimumSimilarity, int prefixLength) { return new FuzzyQuery(term,minimumSimilarity,prefixLength); }
/** {@inheritDoc} */ @Override public Query doQuery(SingleColumnMapper<?> mapper, Analyzer analyzer) { if (mapper.base == String.class) { Term term = new Term(field, value); return new FuzzyQuery(term, maxEdits, prefixLength, maxExpansions, transpositions); } else { throw new IndexException("Fuzzy queries are not supported by mapper {}", mapper); } }
public SearchEngineQuery fuzzy(String resourcePropertyName, String value, float minimumSimilarity) { Query query = new FuzzyQuery(new Term(resourcePropertyName, value), minimumSimilarity); return new LuceneSearchEngineQuery(searchEngineFactory, query); }
BooleanQuery booleanQuery = new BooleanQuery(); FuzzyQuery field1Query = new FuzzyQuery(new Term("field1", searchTerm), 0.3f, 1, 10); FuzzyQuery field2Query = new FuzzyQuery(new Term("field2", searchTerm), 0.3f, 1, 10); booleanQuery.add(field1Query , BooleanClause.Occur.SHOULD); booleanQuery.add(field1Query , BooleanClause.Occur.SHOULD);
@Override public Query fuzzyQuery(Object value, Fuzziness fuzziness, int prefixLength, int maxExpansions, boolean transpositions) { failIfNotIndexed(); return new FuzzyQuery(new Term(name(), indexedValueForSearch(value)), fuzziness.asDistance(BytesRefs.toString(value)), prefixLength, maxExpansions, transpositions); }
@Override public FuzzyQuery build(QueryNode queryNode) throws QueryNodeException { FuzzyQueryNode fuzzyNode = (FuzzyQueryNode) queryNode; String text = fuzzyNode.getTextAsString(); int numEdits = FuzzyQuery.floatToEdits(fuzzyNode.getSimilarity(), text.codePointCount(0, text.length())); return new FuzzyQuery(new Term(fuzzyNode.getFieldAsString(), fuzzyNode .getTextAsString()), numEdits, fuzzyNode .getPrefixLength()); }