final SpanBooleanQueryNode booleanNode = (SpanBooleanQueryNode) queryNode; final List<QueryNode> children = booleanNode.getChildren(); final BooleanSpanQuery bq = new BooleanSpanQuery(booleanNode.getSlop(), booleanNode.isInOrder()); if (obj != null) { if (obj instanceof SpanQuery) { bq.add((SpanQuery) obj, NodeQueryBuilderUtil.getModifierValue(child, NodeBooleanClause.Occur.SHOULD));
@Override public Query rewrite(final IndexReader reader) throws IOException { BooleanSpanQuery clone = null; final NodeQuery query = (NodeQuery) this.nodeBooleanQuery.rewrite(reader); if (query != this.nodeBooleanQuery) { // clause rewrote: must clone clone = (BooleanSpanQuery) this.clone(); if (query instanceof NodeBooleanQuery) { clone.nodeBooleanQuery = (NodeBooleanQuery) query; return clone; } else { // not a boolean query anymore, must have been a 1-clause query return query; } } // no clauses rewrote return this; }
@Override public String toString(final String field) { String str = this.nodeBooleanQuery.toString(field); final boolean hasBoost = (this.getBoost() != 1.0); if (hasBoost) { // remove boost int i = str.lastIndexOf('^'); str = str.substring(0, i); } final StringBuilder builder = new StringBuilder(); builder.append(str); if (inOrder) { // append slop builder.append('#'); } else { builder.append('~'); } builder.append(slop); if (hasBoost) { // append boost builder.append(ToStringUtils.boost(this.getBoost())); } return builder.toString(); }
public BooleanSpanQueryBuilder inOrder(final boolean inOrder) { BooleanSpanQuery bsq = new BooleanSpanQuery(this.bsq.getSlop(), inOrder); for (final NodeBooleanClause clause : this.bsq.getClauses()) { bsq.add((SpanQuery) clause.getQuery(), clause.getOccur()); } this.bsq = bsq; return this; }
public BooleanSpanQueryBuilder slop(final int slop) { BooleanSpanQuery bsq = new BooleanSpanQuery(slop, this.bsq.isInOrder()); for (final NodeBooleanClause clause : this.bsq.getClauses()) { bsq.add((SpanQuery) clause.getQuery(), clause.getOccur()); } this.bsq = bsq; return this; }
NodeSpanQuery term1 = new NodeSpanQuery(ntq("aaa").getQuery()); NodeSpanQuery term2 = new NodeSpanQuery(ntq("bbb").getQuery()); final BooleanSpanQuery bsq1 = new BooleanSpanQuery(0, true); bsq1.add(term1, NodeBooleanClause.Occur.MUST); bsq1.add(term2, NodeBooleanClause.Occur.MUST); final BooleanSpanQuery bsq2 = new BooleanSpanQuery(0, true); bsq2.add(term3, NodeBooleanClause.Occur.MUST); bsq2.add(term4, NodeBooleanClause.Occur.MUST); final BooleanSpanQuery bsq3 = new BooleanSpanQuery(1, true); bsq3.add(term3, NodeBooleanClause.Occur.MUST); bsq3.add(term4, NodeBooleanClause.Occur.MUST); final BooleanSpanQuery bsq4 = new BooleanSpanQuery(0, true); bsq4.add(term1, NodeBooleanClause.Occur.MUST); bsq4.add(term5, NodeBooleanClause.Occur.MUST); final BooleanSpanQuery bsq5 = new BooleanSpanQuery(0, true); bsq5.add(term1, NodeBooleanClause.Occur.MUST); bsq5.add(term2, NodeBooleanClause.Occur.MUST); bsq5.setLevelConstraint(3); final BooleanSpanQuery bsq6 = new BooleanSpanQuery(0, true); bsq6.add(term1, NodeBooleanClause.Occur.MUST); bsq6.add(term2, NodeBooleanClause.Occur.MUST); bsq6.setNodeConstraint(5);
@Test public void testSetLevelConstraint() { NodeSpanQuery term1 = new NodeSpanQuery(ntq("aaa").getQuery()); NodeSpanQuery term2 = new NodeSpanQuery(ntq("bbb").getQuery()); final BooleanSpanQuery bsq1 = new BooleanSpanQuery(0, true); bsq1.add(term1, NodeBooleanClause.Occur.MUST); bsq1.add(term2, NodeBooleanClause.Occur.MUST); bsq1.setLevelConstraint(3); assertEquals(3, bsq1.getLevelConstraint()); // Level constraint must have been transferred to the clauses assertEquals(3, bsq1.getClauses()[0].getQuery().getLevelConstraint()); assertEquals(3, bsq1.getClauses()[1].getQuery().getLevelConstraint()); NodeSpanQuery term3 = new NodeSpanQuery(ntq("aaa").getQuery()); NodeSpanQuery term4 = new NodeSpanQuery(ntq("bbb").getQuery()); final BooleanSpanQuery bsq2 = new BooleanSpanQuery(0, true); bsq2.add(term3, NodeBooleanClause.Occur.MUST); bsq2.add(term4, NodeBooleanClause.Occur.MUST); bsq2.setLevelConstraint(4); final NearSpanQuery nsq3 = new NearSpanQuery(new SpanQuery[] {bsq1, bsq2}, 0, true); nsq3.setLevelConstraint(6); // Level constraint must have been transferred to the clauses assertEquals(6, bsq1.getLevelConstraint()); assertEquals(6, bsq1.getLevelConstraint()); }
@Test public void testSetAncestorPointer() { NodeSpanQuery term1 = new NodeSpanQuery(ntq("aaa").getQuery()); NodeSpanQuery term2 = new NodeSpanQuery(ntq("bbb").getQuery()); final BooleanSpanQuery bsq1 = new BooleanSpanQuery(0, true); bsq1.add(term1, NodeBooleanClause.Occur.MUST); bsq1.add(term2, NodeBooleanClause.Occur.MUST); final TwigQuery twig = new TwigQuery(); bsq1.setAncestorPointer(twig); assertSame(twig, bsq1.getAncestorPointer()); // clauses must have been updated assertSame(twig, term1.getAncestorPointer()); }
final BooleanSpanQuery bsq = new BooleanSpanQuery(slop, inOrder); for (final QueryNode child : booleanNode.getChildren()) { final Object obj = child.getTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID); try { bsq.add(new NodeSpanQuery((NodeQuery) obj), this.getNodeModifierValue(child)); bsq.setNodeConstraint(range[0], range[1]);
@Test public void testLevelAndNodeConstraintPropagation() throws IOException { final TwigQuery tq1 = new TwigQuery(2); tq1.addDescendant(2, new NodeTermQuery(new Term("field", "aaa")), NodeBooleanClause.Occur.MUST); tq1.setNodeConstraint(1,2); final TwigQuery tq2 = new TwigQuery(2); tq2.addChild(new NodeTermQuery(new Term("field", "bbb")), NodeBooleanClause.Occur.MUST); final BooleanSpanQuery bsq1 = new BooleanSpanQuery(0, true); bsq1.add(new NodeSpanQuery(tq1), NodeBooleanClause.Occur.MUST); bsq1.add(new NodeSpanQuery(tq2), NodeBooleanClause.Occur.MUST); // Level constraints applied on the twig must not be modified assertEquals(2, tq1.getLevelConstraint()); assertEquals(4, tq1.clauses().get(0).getQuery().getLevelConstraint()); assertEquals(2, tq2.getLevelConstraint()); assertEquals(3, tq2.clauses().get(0).getQuery().getLevelConstraint()); // Node constraints applied on the twig must not be modified assertEquals(1, tq1.getNodeConstraint()[0]); assertEquals(2, tq1.getNodeConstraint()[1]); // Constraints should not be modified after a rewrite final BooleanSpanQuery rewritten = (BooleanSpanQuery) bsq1.rewrite(reader); NodeSpanQuery nodeSpanQuery = (NodeSpanQuery) rewritten.getClauses()[0].getQuery(); assertEquals(2, nodeSpanQuery.getQuery().getLevelConstraint()); assertEquals(1, nodeSpanQuery.getQuery().getNodeConstraint()[0]); assertEquals(2, nodeSpanQuery.getQuery().getNodeConstraint()[1]); nodeSpanQuery = (NodeSpanQuery) rewritten.getClauses()[1].getQuery(); assertEquals(2, nodeSpanQuery.getQuery().getLevelConstraint()); }
private BooleanSpanQuery toBooleanSpanQuery() throws QueryNodeException { int slop = this.hasSlop() ? this.getSlop() : BooleanQueryNodeBuilder.DEFAULT_SLOP; boolean inOrder = this.hasInOrder() ? this.getInOrder() : BooleanQueryNodeBuilder.DEFAULT_INORDER; final BooleanSpanQuery query = new BooleanSpanQuery(slop, inOrder); // convert clauses for (final QueryClause clause : clauses) { final SpanQuery q = new NodeSpanQuery((com.sindicetech.siren.search.node.NodeQuery) clause.getQuery().toQuery(false)); query.add(q, clause.getNodeBooleanOccur()); } return query; }
private BooleanSpanQueryBuilder(final BooleanBag[] clauses) { bsq = new BooleanSpanQuery(0, false); for (final BooleanBag bag : clauses) { for (final NodeBooleanClause clause : bag.toNodeBooleanClauses()) { bsq.add((SpanQuery) clause.getQuery(), clause.getOccur()); } } }
@Test public void testRegexQueries() throws Exception { BooleanSpanQuery bsq = new BooleanSpanQuery(0, false); bsq.add(tsq("aaa").getQuery(), NodeBooleanClause.Occur.MUST); NodeRegexpQuery regexp = new NodeRegexpQuery(new Term(SirenTestCase.DEFAULT_TEST_FIELD, "s*e")); regexp.setDatatype("http://www.w3.org/2001/XMLSchema#string"); bsq.add(new MultiTermSpanQuery<>(regexp), NodeBooleanClause.Occur.MUST); this._assertSirenQuery(new LuceneProxyNodeQuery(bsq), "(aaa AND /s*e/)~0"); }
@Test public void testFuzzyQueries() throws Exception { BooleanSpanQuery bsq = new BooleanSpanQuery(0, false); bsq.add(tsq("aaa").getQuery(), NodeBooleanClause.Occur.MUST); NodeFuzzyQuery fuzzy = new NodeFuzzyQuery(new Term(SirenTestCase.DEFAULT_TEST_FIELD, "bbb")); fuzzy.setDatatype("http://www.w3.org/2001/XMLSchema#string"); bsq.add(new MultiTermSpanQuery<>(fuzzy), NodeBooleanClause.Occur.MUST); this._assertSirenQuery(new LuceneProxyNodeQuery(bsq), "(aaa AND bbb~)~0"); }
@Test public void testReqWithSlop() throws Exception { this.addDocuments( doc(token("aaa", node(1)), token("bbb", node(1), 2)) ); TermSpanQuery term1 = new TermSpanQuery(new Term(DEFAULT_TEST_FIELD, "aaa")); TermSpanQuery term2 = new TermSpanQuery(new Term(DEFAULT_TEST_FIELD, "bbb")); // should not match BooleanSpanQuery bsq1 = new BooleanSpanQuery(0, true); bsq1.add(term1, NodeBooleanClause.Occur.MUST); bsq1.add(term2, NodeBooleanClause.Occur.MUST); Query query = new LuceneProxyNodeQuery(bsq1); TopDocs hits = searcher.search(query, 100); assertEquals(0, hits.totalHits); // should match bsq1 = new BooleanSpanQuery(1, true); bsq1.add(term1, NodeBooleanClause.Occur.MUST); bsq1.add(term2, NodeBooleanClause.Occur.MUST); query = new LuceneProxyNodeQuery(bsq1); hits = searcher.search(query, 100); assertEquals(1, hits.totalHits); bsq1 = new BooleanSpanQuery(2, true); bsq1.add(term1, NodeBooleanClause.Occur.MUST); bsq1.add(term2, NodeBooleanClause.Occur.MUST); query = new LuceneProxyNodeQuery(bsq1); hits = searcher.search(query, 100); assertEquals(1, hits.totalHits); }
@Test public void testNotSameNode() throws Exception { this.addDocuments( doc(token("aaa", node(1)), token("bbb", node(2))) ); TermSpanQuery term1 = new TermSpanQuery(new Term(DEFAULT_TEST_FIELD, "aaa")); TermSpanQuery term2 = new TermSpanQuery(new Term(DEFAULT_TEST_FIELD, "bbb")); final BooleanSpanQuery bsq1 = new BooleanSpanQuery(0, true); bsq1.add(term1, NodeBooleanClause.Occur.MUST); bsq1.add(term2, NodeBooleanClause.Occur.MUST); Query query = new LuceneProxyNodeQuery(bsq1); TopDocs hits = searcher.search(query, 100); assertEquals(0, hits.totalHits); }
@Test public void testReqExcludeWithSlop() throws IOException { this.addDocuments( doc(token("aaa", node(1,2)), token("bbb", node(1,2)), token("ccc", node(1,2))), doc(token("aaa", node(1,3)), token("ccc", node(1,3)), token("bbb", node(1,3))) ); TermSpanQuery term1 = new TermSpanQuery(new Term(DEFAULT_TEST_FIELD, "aaa")); TermSpanQuery term2 = new TermSpanQuery(new Term(DEFAULT_TEST_FIELD, "bbb")); TermSpanQuery term3 = new TermSpanQuery(new Term(DEFAULT_TEST_FIELD, "ccc")); BooleanSpanQuery bsq1 = new BooleanSpanQuery(1, true); bsq1.add(term1, NodeBooleanClause.Occur.MUST); bsq1.add(term2, NodeBooleanClause.Occur.MUST_NOT); bsq1.add(term3, NodeBooleanClause.Occur.MUST); Query query = new LuceneProxyNodeQuery(bsq1); TopDocs hits = searcher.search(query, 100); assertEquals(1, hits.totalHits); }
@Test public void testReqOptWithSlop() throws Exception { this.addDocuments( doc(token("aaa", node(1)), token("ccc", node(1), 2), token("bbb", node(1))), doc(token("aaa", node(1)), token("ccc", node(1)), token("bbb", node(1))), doc(token("aaa", node(1)), token("bbb", node(1)), token("ccc", node(1))), doc(token("aaa", node(1)), token("ccc", node(1), 2), token("bbb", node(1), 2)) ); TermSpanQuery term1 = new TermSpanQuery(new Term(DEFAULT_TEST_FIELD, "aaa")); TermSpanQuery term2 = new TermSpanQuery(new Term(DEFAULT_TEST_FIELD, "bbb")); TermSpanQuery term3 = new TermSpanQuery(new Term(DEFAULT_TEST_FIELD, "ccc")); BooleanSpanQuery bsq1 = new BooleanSpanQuery(1, true); bsq1.add(term1, NodeBooleanClause.Occur.MUST); bsq1.add(term2, NodeBooleanClause.Occur.SHOULD); bsq1.add(term3, NodeBooleanClause.Occur.MUST); Query query = new LuceneProxyNodeQuery(bsq1); TopDocs hits = searcher.search(query, 100); assertEquals(4, hits.totalHits); float[] scores = new float[4]; for (int i = 0; i < 4; i ++) { scores[hits.scoreDocs[i].doc] = hits.scoreDocs[i].score; } // second and third documents match without slop and matches the optional term bbb assertEquals(scores[1], scores[2], 0); // first document matches with a slop of 1 and matches the optional term bbb assertTrue(scores[0] < scores[1]); // fourth document matches with a slop of 1 but does not match the optional term bbb assertTrue(scores[3] < scores[0]); }
@Test public void testAsTwigChild() throws Exception { this.addDocuments( doc(token("aa", node(1)), token("aaa", node(1,1)), token("bbb", node(1,3))), doc(token("bb", node(1)), token("aaa", node(1,1)), token("bbb", node(1,3))) ); NodeSpanQuery term1 = new NodeSpanQuery(ntq("aaa").getQuery()); NodeSpanQuery term2 = new NodeSpanQuery(ntq("bbb").getQuery()); BooleanSpanQuery bsq = new BooleanSpanQuery(1, true); bsq.add(term1, NodeBooleanClause.Occur.MUST); bsq.add(term2, NodeBooleanClause.Occur.MUST); TwigQuery twig = new TwigQuery(); twig.addRoot(ntq("aa").getQuery()); twig.addChild(bsq, NodeBooleanClause.Occur.MUST); Query query = new LuceneProxyNodeQuery(twig); TopDocs hits = searcher.search(query, 100); assertEquals(1, hits.totalHits); }
@Test public void testAsTwigDescendant() throws Exception { this.addDocuments( doc(token("aa", node(1)), token("aaa", node(1,1)), token("bbb", node(1,3))), doc(token("aa", node(1)), token("aaa", node(1,1,1)), token("bbb", node(1,1,3))), doc(token("bb", node(1)), token("aaa", node(1,1,1)), token("bbb", node(1,1,3))) ); NodeSpanQuery term1 = new NodeSpanQuery(ntq("aaa").getQuery()); NodeSpanQuery term2 = new NodeSpanQuery(ntq("bbb").getQuery()); BooleanSpanQuery bsq = new BooleanSpanQuery(1, true); bsq.add(term1, NodeBooleanClause.Occur.MUST); bsq.add(term2, NodeBooleanClause.Occur.MUST); TwigQuery twig = new TwigQuery(); twig.addRoot(ntq("aa").getQuery()); twig.addDescendant(2, bsq, NodeBooleanClause.Occur.MUST); Query query = new LuceneProxyNodeQuery(twig); TopDocs hits = searcher.search(query, 100); assertEquals(1, hits.totalHits); }