@Override public void extractTerms(final Set<Term> terms) { for (final NodeBooleanClause clause : clauses) { clause.getQuery().extractTerms(terms); } }
@Override protected void initWeights(final IndexSearcher searcher) throws IOException { weights = new ArrayList<Weight>(clauses.size()); for (int i = 0; i < clauses.size(); i++) { final NodeBooleanClause c = clauses.get(i); final NodeQuery q = c.getQuery(); weights.add(q.createWeight(searcher)); } }
/** * Adds a clause to a boolean query. * * @throws TooManyClauses * if the new number of clauses exceeds the maximum clause number * @see #getMaxClauseCount() */ public void add(final NodeBooleanClause clause) { if (clauses.size() >= maxClauseCount) { throw new TooManyClauses(); } clauses.add(clause); // keep the clause synchronised in term of constraint management clause.getQuery().setLevelConstraint(levelConstraint); clause.getQuery().setNodeConstraint(lowerBound, upperBound); clause.getQuery().setAncestorPointer(ancestor); }
@Override public void setAncestorPointer(final NodeQuery ancestor) { super.setAncestorPointer(ancestor); // keep clauses synchronised for (final NodeBooleanClause clause : clauses) { clause.getQuery().setAncestorPointer(ancestor); } }
@Override public void extractTerms(final Set<Term> terms) { root.extractTerms(terms); for (final NodeBooleanClause clause : clauses) { clause.getQuery().extractTerms(terms); } }
@Override public void setNodeConstraint(final int lowerBound, final int upperBound) { super.setNodeConstraint(lowerBound, upperBound); // keep clauses synchronised for (final NodeBooleanClause clause : clauses) { clause.getQuery().setNodeConstraint(lowerBound, upperBound); } }
@Override public void setLevelConstraint(final int levelConstraint) { super.setLevelConstraint(levelConstraint); // keep clauses synchronised for (final NodeBooleanClause clause : clauses) { clause.getQuery().setLevelConstraint(levelConstraint); } }
/** * Adds a clause to a tuple query. * * @throws TooManyClauses * if the new number of clauses exceeds the maximum clause number * @see #getMaxClauseCount() */ public void add(final NodeBooleanClause clause) { super.addChild(clause.getQuery(), clause.getOccur()); }
@Override protected void initWeights(final IndexSearcher searcher) throws IOException { weights = new ArrayList<Weight>(clauses.size()); for (int i = 0; i < clauses.size(); i++) { final NodeBooleanClause c = clauses.get(i); final NodeQuery q = c.getQuery(); // pass to child query the node constraints q.setNodeConstraint(lowerBound, upperBound); q.setLevelConstraint(levelConstraint); // transfer ancestor pointer to child q.setAncestorPointer(ancestor); weights.add(q.createWeight(searcher)); } }
/** Prints a user-readable version of this query. */ @Override public String toString(final String field) { final StringBuilder buffer = new StringBuilder(); final boolean hasBoost = (this.getBoost() != 1.0); buffer.append("("); for (int i = 0; i < clauses.size(); i++) { final NodeBooleanClause c = clauses.get(i); if (c.isProhibited()) buffer.append("-"); else if (c.isRequired()) buffer.append("+"); final Query subQuery = c.getQuery(); if (subQuery != null) { buffer.append(subQuery.toString(field)); } if (i != clauses.size() - 1) buffer.append(" "); } buffer.append(")"); if (hasBoost) { buffer.append(ToStringUtils.boost(this.getBoost())); } return buffer.toString(); }
private TwigQuery rewriteClauses(TwigQuery clone, final IndexReader reader) throws IOException { for (int i = 0 ; i < clauses.size(); i++) { final NodeBooleanClause c = clauses.get(i); final NodeQuery query = (NodeQuery) c.getQuery().rewrite(reader); if (query != c.getQuery()) { // clause rewrote: must clone if (clone == null) { clone = (TwigQuery) this.clone(); // clone and set root since clone is null, i.e., root has not been rewritten clone.root = (NodeQuery) this.root.clone(); // copy ancestor clone.root.setAncestorPointer(ancestor); } // set root as ancestor query.setAncestorPointer(clone.root); clone.clauses.set(i, new NodeBooleanClause(query, c.getOccur())); } } return clone; }
@Override public void setLevelConstraint(final int levelConstraint) { // Do not update the level constraint if it is the sentinel value - cf. #19 if (levelConstraint != -1) { // store the current level constraint before updating final int oldLevelConstraint = this.levelConstraint; // update level constraint super.setLevelConstraint(levelConstraint); // update level constraint of the root root.setLevelConstraint(levelConstraint); // update level of childs and descendants NodeQuery q; for (final NodeBooleanClause clause : clauses) { q = clause.getQuery(); // compute delta between old level and descendant level final int levelDelta = q.getLevelConstraint() - oldLevelConstraint; // update level of descendant q.setLevelConstraint(levelConstraint + levelDelta); } } }
private void checkBooleanTerms(final NodeTermRangeQuery query, final String... terms) throws IOException { query.setRewriteMethod(new MultiNodeTermQuery.TopTermsScoringNodeBooleanQueryRewrite(50)); final NodeBooleanQuery bq = (NodeBooleanQuery) searcher.rewrite(query); final Set<String> allowedTerms = new HashSet<String>(Arrays.asList(terms)); assertEquals(allowedTerms.size(), bq.clauses().size()); for (final NodeBooleanClause c : bq.clauses()) { assertTrue(c.getQuery() instanceof NodeTermQuery); final NodeTermQuery tq = (NodeTermQuery) c.getQuery(); final String term = tq.getTerm().text(); assertTrue("invalid term: "+ term, allowedTerms.contains(term)); allowedTerms.remove(term); // remove to fail on double terms } assertEquals(0, allowedTerms.size()); }
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()); } } }
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; }
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; }
@Test public void testTwigWithVariableAsChildWithoutMust() throws QueryNodeException { String query = "{" + "\"twig\" : {" + "\"child\" : [ {" + "\"variable\" : {}" + "} ]" + "}" +"}"; Query q = new ExtendedTreeQueryParser().parse(query, ""); com.sindicetech.siren.search.node.NodeQuery nq = ((LuceneProxyNodeQuery)q).getNodeQuery(); assertThat(nq, instanceOf(com.sindicetech.siren.search.node.TwigQuery.class)); assertThat(((com.sindicetech.siren.search.node.TwigQuery)nq).getClauses()[0], instanceOf(NodeBooleanClause.class)); assertThat(((com.sindicetech.siren.search.node.TwigQuery)nq).getClauses()[0].getQuery(), instanceOf(NodeVariableQuery.class)); // Occur has to be SHOULD by default. See the comment in ChildPropertyParser for explanation assertEquals(((com.sindicetech.siren.search.node.TwigQuery)nq).getClauses()[0].getOccur() , Occur.SHOULD); }
@Test public void testTwigWithVariableAsChild() throws QueryNodeException { String query = "{" + "\"twig\" : {" + "\"child\" : [ {" + "\"occur\" : \"MUST\"," + "\"variable\" : {}" + "} ]" + "}" +"}"; Query q = new ExtendedTreeQueryParser().parse(query, ""); com.sindicetech.siren.search.node.NodeQuery nq = ((LuceneProxyNodeQuery)q).getNodeQuery(); assertThat(nq, instanceOf(com.sindicetech.siren.search.node.TwigQuery.class)); assertThat(((com.sindicetech.siren.search.node.TwigQuery)nq).getClauses()[0] , instanceOf(NodeBooleanClause.class)); assertThat(((com.sindicetech.siren.search.node.TwigQuery)nq).getClauses()[0].getQuery() , instanceOf(NodeVariableQuery.class)); // Occur has to be rewritten to SHOULD in ChildPropertyParser - see the comment there for explanation assertEquals(((com.sindicetech.siren.search.node.TwigQuery)nq).getClauses()[0].getOccur() , Occur.SHOULD); }
@Test public void testSetLevelConstraint() { final TwigQuery tq1 = new TwigQuery(2); tq1.addDescendant(2, new NodeTermQuery(new Term("field", "value")), Occur.MUST); assertEquals(2, tq1.getLevelConstraint()); // Descendant node level must be relative to the twig level assertEquals(4, tq1.clauses().get(0).getQuery().getLevelConstraint()); tq1.setLevelConstraint(3); assertEquals(3, tq1.getLevelConstraint()); // level of descendant node must have been updated assertEquals(5, tq1.clauses().get(0).getQuery().getLevelConstraint()); final TwigQuery tq2 = new TwigQuery(); tq2.addChild(tq1, Occur.MUST); // level of tq1 must have been updated assertEquals(2, tq1.getLevelConstraint()); // level of descendant node must have been updated assertEquals(4, tq1.clauses().get(0).getQuery().getLevelConstraint()); final TwigQuery tq3 = new TwigQuery(3); tq3.addRoot(tq2); // level of tq2 must have been updated assertEquals(3, tq2.getLevelConstraint()); // level of tq1 must have been updated assertEquals(4, tq1.getLevelConstraint()); // level of descendant node must have been updated assertEquals(6, tq1.clauses().get(0).getQuery().getLevelConstraint()); }
@Test public void testSetAncestorPointer() { final NodeTermQuery term = new NodeTermQuery(new Term("field", "value")); final TwigQuery tq1 = new TwigQuery(); tq1.addDescendant(2, term, Occur.MUST); // ancestor of term query must be the root of the twig assertSame(tq1.getRoot(), term.ancestor); // ancestor of the twig must be null assertNull(tq1.ancestor); final TwigQuery tq2 = new TwigQuery(); tq2.addChild(tq1, Occur.MUST); // ancestor of tq1 and of its root must have been updated assertSame(tq2.getRoot(), tq1.ancestor); assertSame(tq2.getRoot(), tq1.getRoot().ancestor); // ancestor of tq1's descendant must have not changed assertEquals(4, tq1.clauses().get(0).getQuery().getLevelConstraint()); final TwigQuery tq3 = new TwigQuery(3); tq3.addRoot(tq2); // ancestor of tq2 and of its root must be the ancestor of tq3 assertSame(tq3.ancestor, tq2.ancestor); assertSame(tq2.ancestor, tq2.getRoot().ancestor); }