public BooleanQuery clone(final BooleanParent newParent, final Occur occur, final boolean generated) { final BooleanQuery bq = new BooleanQuery(newParent, occur, generated); for (final BooleanClause clause : clauses) { bq.addClause(clause.clone(bq, generated)); } return bq; } }
@Override public Node visitNoopQuery(NoopQueryContext ctx) { BooleanQuery parent = booleanQueryStack.getLast(); if (parent != this.query) { BooleanQuery bq = new BooleanQuery(parent, getOccur(), false); parent.addClause(bq); operatorStack.add(Operator.NONE); booleanQueryStack.add(query); } super.visitNoopQuery(ctx); if (parent != this.query) { operatorStack.removeLast(); return booleanQueryStack.removeLast(); } else { return parent; } }
@Override public Node visit(final BooleanQuery booleanQuery) { final BooleanQuery newBQ = new BooleanQuery((BooleanParent) getNewParent(), booleanQuery.occur, true); newParentStack.add(newBQ); for (final BooleanClause clause : booleanQuery.getClauses()) { newBQ.addClause((BooleanClause) clause.accept(this)); } newParentStack.removeLast(); return newBQ; }
@Override public Node visitBooleanQuery(BooleanQueryContext ctx) { Operator op = Operator.NONE; List<OpAndContext> and = ctx.getRuleContexts(OpAndContext.class); if (and != null && !and.isEmpty()) { op = Operator.AND; } else { List<OpOrContext> or = ctx.getRuleContexts(OpOrContext.class); if (or != null && !or.isEmpty()) { op = Operator.OR; } } BooleanQuery parent = booleanQueryStack.getLast(); BooleanQuery query = new BooleanQuery(parent, getOccur(), false); parent.addClause(query); operatorStack.add(op); booleanQueryStack.add(query); super.visitBooleanQuery(ctx); operatorStack.removeLast(); return booleanQueryStack.removeLast(); }
protected void decompound(final Term term) { // determine the nodesToAdd based on the term try { for (final SuggestWord[] decompounded : suggestWordbreaks(term)) { if (decompounded != null && decompounded.length > 0) { final BooleanQuery bq = new BooleanQuery(term.getParent(), Clause.Occur.SHOULD, true); for (final SuggestWord word : decompounded) { final DisjunctionMaxQuery dmq = new DisjunctionMaxQuery(bq, Clause.Occur.MUST, true); bq.addClause(dmq); dmq.addClause(new Term(dmq, term.getField(), word.string, true)); } nodesToAdd.add(bq); } } } catch (final IOException e) { // IO is broken, this looks serious -> throw as RTE throw new RuntimeException("Error decompounding " + term, e); } }
final BooleanQuery bq = new BooleanQuery(match.getParent(), Occur.SHOULD, true); match.getParent().addClause(bq); for (final querqy.rewrite.commonrules.model.Term synTerm: synonym) { addSynonymTermToDisjunctionMaxQuery(clauseDmq, synonym.get(0), termMatches); } else { final BooleanQuery bq = new BooleanQuery(clauseDmq, Occur.SHOULD, true); clauseDmq.addClause(bq);
if (scratchChars[i] == ' ' && (i > start)) { if (add == null) { add = new BooleanQuery(currentDmq, Occur.SHOULD, true);
: new BooleanQuery(query.getParent(), query.getOccur(), true);
BooleanQuery add = new BooleanQuery(currentDmq, Occur.SHOULD, true); BooleanQuery replaceSeq = new BooleanQuery(add, Occur.MUST, true); BooleanQuery neq = new BooleanQuery(add, Occur.MUST_NOT, true);
@Test public void testThatClonePreservesGeneratedAndOccur() throws Exception { BooleanQuery bq = new BooleanQuery(null, MUST_NOT, true); final BooleanClause clone = bq.clone(null); assertEquals(MUST_NOT, clone.getOccur()); assertTrue(clone.isGenerated()); }
@Test public void testThatGeneratedIsPropagatedToClauses() throws Exception { BooleanQuery bq = new BooleanQuery(null, SHOULD, false); DisjunctionMaxQuery dmq = new DisjunctionMaxQuery(bq, Clause.Occur.SHOULD, false); bq.addClause(dmq); dmq.addClause(new Term(dmq, "Test", false)); final BooleanQuery clone = (BooleanQuery) bq.clone(null, MUST, true); assertThat(clone, bq(must(), dmq(should(), term("Test", true)))); assertTrue(clone.isGenerated()); assertTrue(clone.getClauses().get(0).isGenerated()); assertEquals(MUST, clone.getOccur()); } }