@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + Float.floatToIntBits(this.getBoost()); result = prime * result + rewriteMethod.hashCode(); result = prime * result + lowerBound; result = prime * result + upperBound; result = prime * result + levelConstraint; if (field != null) result = prime * result + field.hashCode(); return result; }
/** * Expert: returns the rewriteMethod */ public final SpanRewriteMethod getRewriteMethod() { final MultiNodeTermQuery.RewriteMethod m = query.getRewriteMethod(); if (!(m instanceof SpanRewriteMethod)) throw new UnsupportedOperationException("You can only use MultiTermSpanQuery with a suitable SpanRewriteMethod."); return (SpanRewriteMethod) m; }
/** * Returns the {@link MultiNodeTermQuery}s {@link TermsEnum} * @see MultiNodeTermQuery#getTermsEnum(Terms, AttributeSource) */ protected TermsEnum getTermsEnum(final MultiNodeTermQuery query, final Terms terms, final AttributeSource atts) throws IOException { // allow RewriteMethod subclasses to pull a TermsEnum from the MTQ return query.getTermsEnum(terms, atts); }
this.assertMatches(searcher, wq, 2); final Terms terms = MultiFields.getTerms(searcher.getIndexReader(), DEFAULT_TEST_FIELD); assertTrue(wq.getTermsEnum(terms) instanceof PrefixTermsEnum); wq.setRewriteMethod(MultiNodeTermQuery.SCORING_BOOLEAN_QUERY_REWRITE); wq.setBoost(0.1F); expected.setRewriteMethod(wq.getRewriteMethod()); expected.setBoost(wq.getBoost()); assertEquals(searcher.rewrite(expected), searcher.rewrite(wq)); wq.setRewriteMethod(MultiNodeTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT); wq.setBoost(0.3F); expected.setRewriteMethod(wq.getRewriteMethod()); expected.setBoost(wq.getBoost()); assertEquals(searcher.rewrite(expected), searcher.rewrite(wq)); wq.setRewriteMethod(MultiNodeTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE); wq.setBoost(0.4F); expected.setRewriteMethod(wq.getRewriteMethod()); expected.setBoost(wq.getBoost()); assertEquals(searcher.rewrite(expected), searcher.rewrite(wq)); assertFalse(wq.getTermsEnum(terms) instanceof PrefixTermsEnum); assertFalse(wq.getTermsEnum(terms).getClass().getSimpleName().contains("AutomatonTermsEnum"));
private int countTerms(final MultiNodeTermQuery q) throws Exception { final Terms terms = MultiFields.getTerms(index.reader, q.getField()); if (terms == null) return 0; final TermsEnum termEnum = q.getTermsEnum(terms); assertNotNull(termEnum); int count = 0; BytesRef cur, last = null; while ((cur = termEnum.next()) != null) { count++; if (last != null) { assertTrue(last.compareTo(cur) < 0); } last = BytesRef.deepCopyOf(cur); } // LUCENE-3314: the results after next() already returned null are undefined, // assertNull(termEnum.next()); return count; }
/** * Tests if a SirenWildcardQuery that has no wildcard in the term is rewritten to a single * TermQuery. The boost should be preserved, and the rewrite should return * a SirenConstantScoreQuery if the SirenWildcardQuery had a ConstantScore rewriteMethod. */ public void testTermWithoutWildcard() throws IOException { this.addDocument("<nowildcard> <nowildcardx>"); final MultiNodeTermQuery wq = new NodeWildcardQuery(new Term(DEFAULT_TEST_FIELD, "nowildcard")); this.assertMatches(searcher, wq, 1); wq.setRewriteMethod(MultiNodeTermQuery.SCORING_BOOLEAN_QUERY_REWRITE); wq.setBoost(0.1F); Query q = searcher.rewrite(wq); assertTrue(q instanceof NodeTermQuery); assertEquals(q.getBoost(), wq.getBoost(), 0); wq.setRewriteMethod(MultiNodeTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT); wq.setBoost(0.3F); q = searcher.rewrite(wq); assertTrue(q instanceof NodeConstantScoreQuery); assertEquals(q.getBoost(), wq.getBoost(), 0.1); wq.setRewriteMethod(MultiNodeTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE); wq.setBoost(0.4F); q = searcher.rewrite(wq); assertTrue(q instanceof NodeConstantScoreQuery); assertEquals(q.getBoost(), wq.getBoost(), 0.1); }
@Override public Q rewrite(final IndexReader reader, final MultiNodeTermQuery query) throws IOException { final Q result = this.getTopLevelQuery(query); final ParallelArraysTermCollector col = new ParallelArraysTermCollector(); this.collectTerms(reader, query, col); final int size = col.terms.size(); if (size > 0) { final int sort[] = col.terms.sort(col.termsEnum.getComparator()); final float[] boost = col.array.boost; final TermContext[] termStates = col.array.termState; for (int i = 0; i < size; i++) { final int pos = sort[i]; final Term term = new Term(query.getField(), col.terms.get(pos, new BytesRef())); assert reader.docFreq(term) == termStates[pos].docFreq(); this.addClause(result, term, termStates[pos].docFreq(), query.getBoost() * boost[pos], termStates[pos]); } } return result; }
/** * Tests if the ConstantScore filter rewrite return an exception */ @Test(expected=UnsupportedOperationException.class) public void testFilterRewrite() throws IOException { this.addDocument("<nowildcard> <nowildcardx>"); final MultiNodeTermQuery wq = new NodeWildcardQuery(new Term(DEFAULT_TEST_FIELD, "nowildcard")); this.assertMatches(searcher, wq, 1); wq.setRewriteMethod(MultiNodeTermQuery.CONSTANT_SCORE_FILTER_REWRITE); wq.setBoost(0.2F); searcher.rewrite(wq); }
/** * Expert: sets the rewrite method. This only makes sense * to be a span rewrite method. */ public final void setRewriteMethod(SpanRewriteMethod rewriteMethod) { query.setRewriteMethod(rewriteMethod); }
@Override public int hashCode() { return 31 * query.hashCode(); }
@Override @SuppressWarnings({"rawtypes"}) public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; final MultiTermSpanQuery other = (MultiTermSpanQuery) obj; return query.equals(other.query); }
@Override public void setAncestorPointer(final NodeQuery ancestor) { super.setAncestorPointer(ancestor); this.query.setAncestorPointer(ancestor); }
@Override public Query rewrite(IndexReader reader) throws IOException { final Query q = query.rewrite(reader); if (!(q instanceof SpanQuery)) { throw new UnsupportedOperationException("You can only use MultiTermSpanQuery with a suitable SpanRewriteMethod."); } if (q != this.query) { // transfer constraints ((SpanQuery) q).setNodeConstraint(lowerBound, upperBound); ((SpanQuery) q).setLevelConstraint(levelConstraint); // transfer ancestor pointer ((SpanQuery) q).setAncestorPointer(ancestor); } return q; }
@Test public void testSetLevelConstraint() { NodeWildcardQuery term1 = new NodeWildcardQuery(new Term(DEFAULT_TEST_FIELD, "aaa*")); MultiTermSpanQuery mtsq = new MultiTermSpanQuery(term1); mtsq.setLevelConstraint(3); assertEquals(3, mtsq.getLevelConstraint()); // Level constraint must have been transferred to the clauses assertEquals(3, mtsq.query.getLevelConstraint()); }
private int countTerms(final MultiNodeTermQuery q) throws Exception { final Terms terms = MultiFields.getTerms(index.reader, q.getField()); if (terms == null) return 0; final TermsEnum termEnum = q.getTermsEnum(terms); assertNotNull(termEnum); int count = 0; BytesRef cur, last = null; while ((cur = termEnum.next()) != null) { count++; if (last != null) { assertTrue(last.compareTo(cur) < 0); } last = BytesRef.deepCopyOf(cur); } // LUCENE-3314: the results after next() already returned null are undefined, // assertNull(termEnum.next()); return count; }
/** * Tests if a SirenWildcardQuery with an empty term is rewritten to an empty * SirenBooleanQuery */ public void testEmptyTerm() throws IOException { this.addDocument("<nowildcard> <nowildcardx>"); final MultiNodeTermQuery wq = new NodeWildcardQuery(new Term(DEFAULT_TEST_FIELD, "")); wq.setRewriteMethod(MultiNodeTermQuery.SCORING_BOOLEAN_QUERY_REWRITE); this.assertMatches(searcher, wq, 0); final Query q = searcher.rewrite(wq); assertTrue(q instanceof NodeBooleanQuery); assertEquals(0, ((NodeBooleanQuery) q).clauses().size()); }
@Override public final int hashCode() { int hash = super.hashCode(); hash += precisionStep^0x64365465; if (min != null) hash += min.hashCode()^0x14fa55fb; if (max != null) hash += max.hashCode()^0x733fa5fe; return hash + (Boolean.valueOf(minInclusive).hashCode()^0x14fa55fb)+ (Boolean.valueOf(maxInclusive).hashCode()^0x733fa5fe); }
@Override @SuppressWarnings({"rawtypes"}) public final boolean equals(final Object o) { if (o==this) return true; if (!super.equals(o)) return false; if (o instanceof NodeNumericRangeQuery) { final NodeNumericRangeQuery q=(NodeNumericRangeQuery)o; return ( (q.min == null ? min == null : q.min.equals(min)) && (q.max == null ? max == null : q.max.equals(max)) && minInclusive == q.minInclusive && maxInclusive == q.maxInclusive && precisionStep == q.precisionStep ); } return false; }
@Override public boolean equals(final Object obj) { if (this == obj) return true; if (obj == null) return false; if (this.getClass() != obj.getClass()) return false; final MultiNodeTermQuery other = (MultiNodeTermQuery) obj; if (Float.floatToIntBits(this.getBoost()) != Float.floatToIntBits(other.getBoost())) return false; if (!rewriteMethod.equals(other.rewriteMethod)) { return false; } if (!(this.lowerBound == other.lowerBound && this.upperBound == other.upperBound && this.levelConstraint == other.levelConstraint && StringUtils.equals(this.datatype, other.datatype))) { return false; } return (other.field == null ? field == null : other.field.equals(field)); }
/** * Create a new MultiTermSpanQuery. * * @param query Query to wrap. * <p> * NOTE: This will call {@link MultiNodeTermQuery#setRewriteMethod(MultiNodeTermQuery.RewriteMethod)} * on the wrapped <code>query</code>, changing its rewrite method to a suitable one for spans. * Be sure to not change the rewrite method on the wrapped query afterwards! Doing so will * throw {@link UnsupportedOperationException} on rewriting this query! */ @SuppressWarnings({"rawtypes"}) public MultiTermSpanQuery(Q query) { this.query = query; MultiNodeTermQuery.RewriteMethod method = query.getRewriteMethod(); if (method instanceof TopNodeTermsRewrite) { final int pqsize = ((TopNodeTermsRewrite) method).getSize(); setRewriteMethod(new TopTermsSpanBooleanQueryRewrite(pqsize)); } else { setRewriteMethod(SCORING_SPAN_QUERY_REWRITE); } }