Refine search
/** * 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)); }
@Override protected TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException { if (maxEdits == 0 || prefixLength >= term.text().length()) { // can only match if it's exact return new SingleTermsEnum(terms.iterator(), term.bytes()); } return new FuzzyTermsEnum(terms, atts, getTerm(), maxEdits, prefixLength, transpositions); }
private static void planFuzzyQuery(final StringBuilder builder, final FuzzyQuery query) { builder.append(query.getTerm()); builder.append(",prefixLength="); builder.append(query.getPrefixLength()); builder.append(",maxEdits="); builder.append(query.getMaxEdits()); }
public NodeFuzzyQuery 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 NodeFuzzyQuery(new Term(fuzzyNode.getFieldAsString(), fuzzyNode .getTextAsString()), numEdits, fuzzyNode .getPrefixLength()); }
@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()); }
private static JsonObject convertFuzzyQuery(FuzzyQuery query) { String field = query.getTerm().field(); JsonObject fuzzyQuery = JsonBuilder.object() .add( "fuzzy", JsonBuilder.object().add( field, JsonBuilder.object() .addProperty( "value", query.getTerm().text() ) .addProperty( "fuzziness", query.getMaxEdits() ) .addProperty( "prefix_length", query.getPrefixLength() ) .addProperty( "boost", query.getBoost() ) ) ).build(); return wrapQueryForNestedIfRequired( field, fuzzyQuery ); }
/** * 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) { // FuzzyQuery doesn't yet allow constant score rewrite String text = term.text(); int numEdits = FuzzyQuery.floatToEdits(minimumSimilarity, text.codePointCount(0, text.length())); return new FuzzyQuery(term,numEdits,prefixLength); }
public String toString(String field) { StringBuffer buffer = new StringBuffer(); Term term = getTerm(); if (!term.field().equals(field)) { buffer.append(term.field()); buffer.append(":"); } buffer.append(term.text()); buffer.append('~'); buffer.append(Float.toString(minimumSimilarity)); buffer.append(ToStringUtils.boost(getBoost())); return buffer.toString(); }
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); }
@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; }
final PrefixQuery pq = (PrefixQuery) query; Term prefix = pq.getPrefix(); if (prefix.field().equals(field)) { list.add(new CharacterRunAutomaton(Operations.concatenate(Automata.makeString(prefix.text()), Automata.makeAnyString())) { @Override if (fq.getField().equals(field)) { String utf16 = fq.getTerm().text(); int termText[] = new int[utf16.codePointCount(0, utf16.length())]; for (int cp, i = 0, j = 0; i < utf16.length(); i += Character.charCount(cp)) { int prefixLength = Math.min(fq.getPrefixLength(), termLength); String suffix = UnicodeUtil.newString(termText, prefixLength, termText.length - prefixLength); LevenshteinAutomata builder = new LevenshteinAutomata(suffix, fq.getTranspositions()); String prefix = UnicodeUtil.newString(termText, 0, prefixLength); Automaton automaton = builder.toAutomaton(fq.getMaxEdits(), prefix); list.add(new CharacterRunAutomaton(automaton) { @Override
@Override public Query visit(TermQuery termQuery, Field field) { if( field != Field.CONTENTS ) return termQuery; // turn term query into: (term* OR *term* OR term~) Term term = termQuery.getTerm(); PrefixQuery prefixQuery = new PrefixQuery(term); prefixQuery.setBoost( termQuery.getBoost() ); Term wildcardTerm = Field.CONTENTS.createTerm("*" + term.text() + "*"); WildcardQuery wildcardQuery = new WildcardQuery(wildcardTerm); wildcardQuery.setBoost( termQuery.getBoost() * 0.75f ); FuzzyQuery fuzzyQuery = new FuzzyQuery( term ); fuzzyQuery.setBoost( termQuery.getBoost() * 0.5f ); BooleanQuery boolQuery = new BooleanQuery(); boolQuery.add(prefixQuery, Occur.SHOULD); boolQuery.add(wildcardQuery, Occur.SHOULD); boolQuery.add(fuzzyQuery, Occur.SHOULD); boolQuery.setBoost( termQuery.getBoost() ); return boolQuery; }
/** * 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); }
@Override public Query visit(PhraseQuery phraseQuery) { BooleanQuery bq = new BooleanQuery(); for(Term t: phraseQuery.getTerms()) { Field f = Field.getByName(t.field()); if( f != Field.CONTENTS ) return phraseQuery; bq.add(new FuzzyQuery(t), Occur.SHOULD); } return bq; }
@Override public void writeObject(ObjectOutput output, FuzzyQuery object) throws IOException { output.writeObject(object.getTerm()); output.writeInt(object.getPrefixLength()); output.writeBoolean(object.getTranspositions()); output.writeInt(object.getMaxEdits()); output.writeInt((int) getValue(object, MAX_EXPANSIONS_FIELD)); }
@Override public BLSpanQuery rewrite(IndexReader reader) throws IOException { FuzzyQuery fuzzyQuery = new FuzzyQuery(term, maxEdits, prefixLength); Query rewrittenFuzzyQuery = fuzzyQuery.rewrite(reader); if (rewrittenFuzzyQuery instanceof BooleanQuery) { // BooleanQuery; make SpanQueries from each of the TermQueries and combine with OR List<BooleanClause> clauses = ((BooleanQuery) rewrittenFuzzyQuery).clauses(); BLSpanQuery[] spanQueries = new BLSpanQuery[clauses.size()]; for (int i = 0; i < clauses.size(); i++) { BooleanClause clause = clauses.get(i); TermQuery termQuery = (TermQuery) clause.getQuery(); // ONLY DIFFERENCE WITH SpanFuzzyQuery: // Use a BLSpanTermQuery instead of default Lucene one. spanQueries[i] = new BLSpanTermQuery(termQuery.getTerm()); } BLSpanOrQuery query = new BLSpanOrQuery(spanQueries); query.setHitsAreFixedLength(1); query.setClausesAreSimpleTermsInSameProperty(true); return query; } // Not a BooleanQuery, just a TermQuery. Convert to a SpanTermQuery. BLSpanQuery query = new BLSpanTermQuery(((TermQuery) rewrittenFuzzyQuery).getTerm()); return query; }
protected FilteredTermEnum getEnum(IndexReader reader) throws IOException { return new FuzzyTermEnum(reader, getTerm(), minimumSimilarity, prefixLength); }
FuzzyQueryInfo(String term, FuzzyQuery query) { this.term = term; this.maxEdits = query.getMaxEdits(); this.transpositions = query.getTranspositions(); this.prefixLength = query.getPrefixLength(); }
private int getMaxEditDistance(String term) { int maxEditDistance; if ( termContext.getThreshold() != null ) { //support legacy withThreshold setting maxEditDistance = FuzzyQuery.floatToEdits( termContext.getThreshold(), term.length() ); } else { maxEditDistance = termContext.getMaxEditDistance(); } return maxEditDistance; }
public NodeQuery build(QueryNode queryNode) throws QueryNodeException { FuzzyQueryNode fuzzyNode = (FuzzyQueryNode) queryNode; String text = fuzzyNode.getTextAsString(); int numEdits = FuzzyQuery.floatToEdits(fuzzyNode.getSimilarity(), text.codePointCount(0, text.length())); NodeFuzzyQuery fuzzyQuery = new NodeFuzzyQuery(new Term(fuzzyNode.getFieldAsString(), fuzzyNode.getTextAsString()), numEdits, fuzzyNode.getPrefixLength()); // assign the datatype. We must always have a datatype assigned. fuzzyQuery.setDatatype((String) queryNode.getTag(DatatypeQueryNode.DATATYPE_TAGID)); // if it is tagged as a span query if (fuzzyNode.getTag(QueryTypeProcessor.QUERYTYPE_TAG) == QueryTypeProcessor.SPAN_QUERYTYPE) { return new MultiTermSpanQuery<>(fuzzyQuery); } else { return fuzzyQuery; } }