/** Return the list of relative positions that each term should appear at. */ public int[] getPositions() { return phraseQuery.getPositions(); }
@Override protected Similarity.SimWeight getStats(IndexSearcher searcher) throws IOException { final int[] positions = PhraseQuery.this.getPositions(); if (positions.length < 2) { throw new IllegalStateException("PhraseWeight does not support less than 2 terms, call rewrite first"); } else if (positions[0] != 0) { throw new IllegalStateException("PhraseWeight requires that the first position is 0, call rewrite first"); } final IndexReaderContext context = searcher.getTopReaderContext(); states = new TermContext[terms.length]; TermStatistics termStats[] = new TermStatistics[terms.length]; int termUpTo = 0; for (int i = 0; i < terms.length; i++) { final Term term = terms[i]; states[i] = TermContext.build(context, term); if (needsScores) { TermStatistics termStatistics = searcher.termStatistics(term, states[i]); if (termStatistics != null) { termStats[termUpTo++] = termStatistics; } } } if (termUpTo > 0) { return similarity.computeWeight(boost, searcher.collectionStatistics(field), ArrayUtil.copyOfSubArray(termStats, 0, termUpTo)); } else { return null; // no terms at all, we won't use similarity } }
@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 relative positions that each term should appear at. */ public int[] getPositions() { return phraseQuery.getPositions(); }
/** Return the list of relative positions that each term should appear at. */ public int[] getPositions() { return phraseQuery.getPositions(); }
/** Return the list of relative positions that each term should appear at. */ public int[] getPositions() { return phraseQuery.getPositions(); }
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; }
PhraseQuery pq = (PhraseQuery) innerQuery; Term[] terms = pq.getTerms(); int[] positions = pq.getPositions(); for (int i = 0; i < terms.length; i++) { prefixQuery.add(new Term[]{terms[i]}, positions[i]);
public Scorer scorer(IndexReader reader) throws IOException { if (terms.size() == 0) // optimize zero-term case return null; TermPositions[] tps = new TermPositions[terms.size()]; for (int i = 0; i < terms.size(); i++) { TermPositions p = reader.termPositions((Term)terms.get(i)); if (p == null) return null; tps[i] = p; } if (slop == 0) // optimize exact case return new ExactPhraseScorer(this, tps, getPositions(), similarity, reader.norms(field)); else return new SloppyPhraseScorer(this, tps, getPositions(), similarity, slop, reader.norms(field)); }
public Scorer scorer(IndexReader reader) throws IOException { if (terms.size() == 0) // optimize zero-term case return null; TermPositions[] tps = new TermPositions[terms.size()]; for (int i = 0; i < terms.size(); i++) { TermPositions p = reader.termPositions((Term)terms.get(i)); if (p == null) return null; tps[i] = p; } if (slop == 0) // optimize exact case return new ExactPhraseScorer(this, tps, getPositions(), similarity, reader.norms(field)); else return new SloppyPhraseScorer(this, tps, getPositions(), similarity, slop, reader.norms(field)); }
public Scorer scorer(IndexReader reader) throws IOException { if (terms.size() == 0) // optimize zero-term case return null; TermPositions[] tps = new TermPositions[terms.size()]; for (int i = 0; i < terms.size(); i++) { TermPositions p = reader.termPositions((Term)terms.elementAt(i)); if (p == null) return null; tps[i] = p; } if (slop == 0) // optimize exact case return new ExactPhraseScorer(this, tps, getPositions(), getSimilarity(searcher), reader.norms(field)); else return new SloppyPhraseScorer(this, tps, getPositions(), getSimilarity(searcher), slop, reader.norms(field)); }
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); }
/** * 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(); }
/** * 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(); }
protected Query rewritePhraseQuery(PhraseQuery query) throws RewriteException { Term[] terms = query.getTerms(); int[] positions = query.getPositions(); SpanTermQuery[] spanQueries = new SpanTermQuery[positions.length]; for(int i = 0; i < positions.length; i++) { if(positions[i] - positions[0] != i) { // positions must increase by 1 each time (i-1 is safe as the if can't be true for i=0) throw new RewriteException("Don't know how to rewrite PhraseQuery with holes or overlaps " + "(position must increase by 1 each time but found term " + terms[i-1] + " at position " + positions[i-1] + " followed by term " + terms[i] + " at position " + positions[i] + ")", query); } spanQueries[i] = new SpanTermQuery(terms[i]); } return forceOffsets(new SpanNearQuery(spanQueries, query.getSlop(), true)); }
private Query applySlop(Query q, int slop) { if (q instanceof PhraseQuery) { PhraseQuery.Builder builder = new PhraseQuery.Builder(); builder.setSlop(slop); PhraseQuery pq = (PhraseQuery) q; org.apache.lucene.index.Term[] terms = pq.getTerms(); int[] positions = pq.getPositions(); for (int i = 0; i < terms.length; ++i) { builder.add(terms[i], positions[i]); } q = builder.build(); } else if (q instanceof MultiPhraseQuery) { ((MultiPhraseQuery) q).setSlop(slop); } return q; }
private Query applySlop(Query q, int slop) { if (q instanceof PhraseQuery) { PhraseQuery.Builder builder = new PhraseQuery.Builder(); builder.setSlop(slop); PhraseQuery pq = (PhraseQuery) q; org.apache.lucene.index.Term[] terms = pq.getTerms(); int[] positions = pq.getPositions(); for (int i = 0; i < terms.length; ++i) { builder.add(terms[i], positions[i]); } q = builder.build(); } else if (q instanceof MultiPhraseQuery) { ((MultiPhraseQuery) q).setSlop(slop); } return q; }