/** Return the list of terms. */ public Term[] getTerms() { return phraseQuery.getTerms(); }
private void getPhrases(PhraseQuery query) { Term[] queryTerms = query.getTerms(); for (Term queryTerm : queryTerms) { highlight.add(queryTerm.text()); } }
/** * Decomposes the provided {@code query} into terms. * @param query query to decompose * @return terms that were in the {@code query} */ public static List<Term> intoTerms(final Query query) { if (query == null) { return Collections.emptyList(); } List<Term> terms = new LinkedList<>(); LinkedList<Query> queue = new LinkedList<>(); queue.add(query); while (!queue.isEmpty()) { Query q = queue.poll(); if (q instanceof BooleanQuery) { for (BooleanClause bc : ((BooleanQuery) q).clauses()) { queue.add(bc.getQuery()); } } else if (q instanceof TermQuery) { terms.add(((TermQuery) q).getTerm()); } else if (q instanceof PhraseQuery) { terms.addAll(Arrays.asList(((PhraseQuery) q).getTerms())); } } return terms; }
private void getPhrases(PhraseQuery query) { Term[] queryTerms = query.getTerms(); if (queryTerms.length > 0 && useTerm(queryTerms[0])) { boolean caseInsensitive = isCaseInsensitive(queryTerms[0]); String[] termsArray = new String[queryTerms.length]; for (int i = 0; i < queryTerms.length; i++) { termsArray[i] = queryTerms[i].text(); } matchers.add(new PhraseMatcher(termsArray, caseInsensitive)); } }
@Override public Query rewrite(IndexReader reader) throws IOException { final Term[] terms = phraseQuery.getTerms(); final int[] positions = phraseQuery.getPositions(); boolean isOptimizable = phraseQuery.getSlop() == 0 && n >= 2 // non-overlap n-gram cannot be optimized && terms.length >= 3; // short ones can't be optimized if (isOptimizable) { for (int i = 1; i < positions.length; ++i) { if (positions[i] != positions[i-1] + 1) { isOptimizable = false; break; } } } if (isOptimizable == false) { return phraseQuery.rewrite(reader); } PhraseQuery.Builder builder = new PhraseQuery.Builder(); for (int i = 0; i < terms.length; ++i) { if (i % n == 0 || i == terms.length - 1) { builder.add(terms[i], i); } } return builder.build(); }
/** * Expand a {@link PhraseQuery} to multiple fields that share the same analyzer. * Returns a {@link DisjunctionMaxQuery} with a disjunction for each expanded field. */ static Query blendPhrase(PhraseQuery query, float tiebreaker, FieldAndFieldType... fields) { List<Query> disjunctions = new ArrayList<>(); for (FieldAndFieldType field : fields) { int[] positions = query.getPositions(); Term[] terms = query.getTerms(); PhraseQuery.Builder builder = new PhraseQuery.Builder(); for (int i = 0; i < terms.length; i++) { builder.add(new Term(field.fieldType.name(), terms[i].bytes()), positions[i]); } Query q = builder.build(); if (field.boost != AbstractQueryBuilder.DEFAULT_BOOST) { q = new BoostQuery(q, field.boost); } disjunctions.add(q); } return new DisjunctionMaxQuery(disjunctions, tiebreaker); }
/** * Rebuild a phrase query with a slop value */ private PhraseQuery addSlopToPhrase(PhraseQuery query, int slop) { PhraseQuery.Builder builder = new PhraseQuery.Builder(); builder.setSlop(slop); final Term[] terms = query.getTerms(); final int[] positions = query.getPositions(); for (int i = 0; i < terms.length; ++i) { builder.add(terms[i], positions[i]); } return builder.build(); }
/** Return the list of terms. */ public Term[] getTerms() { return phraseQuery.getTerms(); }
/** Return the list of terms. */ public Term[] getTerms() { return phraseQuery.getTerms(); }
private QueryNode internalParse(org.apache.lucene.search.Query luceneQuery, final String originalStr) throws ParseException { QueryNode node; if (luceneQuery instanceof org.apache.lucene.search.TermQuery) { Term t = ((org.apache.lucene.search.TermQuery) luceneQuery).getTerm(); String field = t.field(); String text = t.text(); node = new TermQuery(field, text); } else if (luceneQuery instanceof org.apache.lucene.search.PrefixQuery) { Term t = ((org.apache.lucene.search.PrefixQuery) luceneQuery).getPrefix(); String field = t.field(); String text = t.text(); node = new PrefixTermQuery(field, text); } else if (luceneQuery instanceof org.apache.lucene.search.BooleanQuery) { List<BooleanClause> clauses = ((org.apache.lucene.search.BooleanQuery) luceneQuery).clauses(); if (clauses.isEmpty()) { throw new ParseException("error parsing: " + originalStr); } node = internalParseBooleanQuery(clauses, originalStr); } else if (luceneQuery instanceof org.apache.lucene.search.PhraseQuery) { org.apache.lucene.search.PhraseQuery phraseQuery = (org.apache.lucene.search.PhraseQuery) luceneQuery; int[] positions = phraseQuery.getPositions(); node = internalParsePhraseQuery(phraseQuery.getTerms(), positions, originalStr); } else { throw new ParseException("unimplemented"); } node.setBoost(luceneQuery.getBoost()); return node; }
public static Query rewrite(PhraseQuery pq, Set<String> intFields) { final List<Query> termQueries = Lists.newArrayListWithCapacity(pq.getTerms().length); for (final org.apache.lucene.index.Term term : pq.getTerms()) { termQueries.add(Query.newTermQuery(rewriteTerm(term, intFields))); } return Query.newBooleanQuery(BooleanOp.AND, termQueries); } }
if (innerQuery instanceof PhraseQuery) { PhraseQuery pq = (PhraseQuery) innerQuery; Term[] terms = pq.getTerms(); int[] positions = pq.getPositions(); for (int i = 0; i < terms.length; i++) {
void saveTerms( Collection<Query> flatQueries ){ for( Query query : flatQueries ){ Set<String> termSet = getTermSet( query ); if( query instanceof TermQuery ) termSet.add( ((TermQuery)query).getTerm().text() ); else if( query instanceof PhraseQuery ){ for( Term term : ((PhraseQuery)query).getTerms() ) termSet.add( term.text() ); } else throw new RuntimeException( "query \"" + query.toString() + "\" must be flatten first." ); } }
private String getKey( Query query ){ if( !fieldMatch ) return null; if( query instanceof TermQuery ) return ((TermQuery)query).getTerm().field(); else if ( query instanceof PhraseQuery ){ PhraseQuery pq = (PhraseQuery)query; Term[] terms = pq.getTerms(); return terms[0].field(); } else throw new RuntimeException( "query \"" + query.toString() + "\" must be flatten first." ); }
private SectionSearchQueryPlan translatePhraseQuery(PhraseQuery query) throws IOException { Term[] terms = query.getTerms(); TermNode[] nodes = new TermNode[terms.length]; int[] positions = query.getPositions(); for (int i = 0; i < terms.length; i++) { nodes[i] = new TermNode(terms[i], positions[i], _reader); } return new PhraseNode(nodes, _reader); }
private void checkOverlap( Collection<Query> expandQueries, PhraseQuery a, float aBoost, PhraseQuery b, float bBoost ){ if( a.getSlop() != b.getSlop() ) return; Term[] ats = a.getTerms(); Term[] bts = b.getTerms(); if( fieldMatch && !ats[0].field().equals( bts[0].field() ) ) return; checkOverlap( expandQueries, ats, bts, a.getSlop(), aBoost); checkOverlap( expandQueries, bts, ats, b.getSlop(), bBoost ); }
private void checkOverlap( Collection<Query> expandQueries, PhraseQuery a, PhraseQuery b ){ if( a.getSlop() != b.getSlop() ) return; Term[] ats = a.getTerms(); Term[] bts = b.getTerms(); if( fieldMatch && !ats[0].field().equals( bts[0].field() ) ) return; checkOverlap( expandQueries, ats, bts, a.getSlop(), a.getBoost() ); checkOverlap( expandQueries, bts, ats, b.getSlop(), b.getBoost() ); }
@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; }
/** * Rebuild a phrase query with a slop value */ private PhraseQuery addSlopToPhrase(PhraseQuery query, int slop) { PhraseQuery.Builder builder = new PhraseQuery.Builder(); builder.setSlop(slop); final Term[] terms = query.getTerms(); final int[] positions = query.getPositions(); for (int i = 0; i < terms.length; ++i) { builder.add(terms[i], positions[i]); } return builder.build(); }
/** * Rebuild a phrase query with a slop value */ private PhraseQuery addSlopToPhrase(PhraseQuery query, int slop) { PhraseQuery.Builder builder = new PhraseQuery.Builder(); builder.setSlop(slop); final Term[] terms = query.getTerms(); final int[] positions = query.getPositions(); for (int i = 0; i < terms.length; ++i) { builder.add(terms[i], positions[i]); } return builder.build(); }