@Override public BooleanClause clone(final BooleanQuery newParent, final Occur occur, final boolean generated) { final DisjunctionMaxQuery dmq = new DisjunctionMaxQuery(newParent, occur, generated); for (final DisjunctionMaxClause clause : clauses) { dmq.addClause(clause.clone(dmq, generated)); } return dmq; }
@Override public DisjunctionMaxQuery visit(final DisjunctionMaxQuery disjunctionMaxQuery) { final DisjunctionMaxQuery newDMQ = new DisjunctionMaxQuery((BooleanQuery) getNewParent(), disjunctionMaxQuery.occur, true); newParentStack.add(newDMQ); for (final DisjunctionMaxClause clause : disjunctionMaxQuery.getClauses()) { newDMQ.addClause((DisjunctionMaxClause) clause.accept(this)); } newParentStack.removeLast(); return newDMQ; }
public void removeIfNotOnlyChild(final Term term) { // remove the term from its parent. If the parent doesn't have any further child, // remove the parent from the grand-parent. If this also hasn't any further child, // do not remove anything // TODO: go until top level? final DisjunctionMaxQuery parentQuery = term.getParent(); if (parentQuery.getClauses().size() > 1) { parentQuery.removeClause(term); } else { final BooleanQuery grandParent = parentQuery.getParent(); if (grandParent != null && grandParent.getClauses().size() > 1) { grandParent.removeClause(parentQuery); } } }
@Override public DisjunctionMaxQuery visit(final DisjunctionMaxQuery disjunctionMaxQuery) { boolean hasPlaceHolderChild = false; final List<DisjunctionMaxClause> oldClauses = disjunctionMaxQuery.getClauses(); final List<DisjunctionMaxClause> newClauses = new ArrayList<>(oldClauses.size()); for (final DisjunctionMaxClause clause : oldClauses) { final DisjunctionMaxClause mayBeRewritten = (DisjunctionMaxClause) clause.accept(this); newClauses.add(mayBeRewritten); hasPlaceHolderChild |= (mayBeRewritten != clause); } if (hasPlaceHolderChild) { for (final DisjunctionMaxClause clause : oldClauses) { disjunctionMaxQuery.removeClause(clause); } for (final DisjunctionMaxClause clause : newClauses) { disjunctionMaxQuery.addClause(clause); } hasPlaceHolder = true; } return disjunctionMaxQuery; }
public void apply() { for (Map.Entry<DisjunctionMaxQuery, Set<DisjunctionMaxClause>> entry : addenda.entrySet()) { DisjunctionMaxQuery dmq = entry.getKey(); for (DisjunctionMaxClause clause : entry.getValue()) { dmq.addClause(clause); } } addenda.clear(); }
public List<Term> getTerms() { return getClauses(Term.class); }
@Override public BooleanClause clone(final BooleanQuery newParent, final Occur occur) { return clone(newParent, this.generated); }
protected void addSynonymTermToDisjunctionMaxQuery(final DisjunctionMaxQuery dmq, final querqy.rewrite.commonrules.model.Term synTerm, final TermMatches termMatches) { final List<String> fieldNames = synTerm.getFieldNames(); final ComparableCharSequence charSequence = synTerm.fillPlaceholders(termMatches); if (fieldNames == null || fieldNames.isEmpty()) { dmq.addClause(new Term(dmq, charSequence, true)); } else { for (final String fieldName: fieldNames) { dmq.addClause(new Term(dmq, fieldName, charSequence, true)); } } }
@Override public T visit(final DisjunctionMaxQuery disjunctionMaxQuery) { for (final DisjunctionMaxClause clause : disjunctionMaxQuery.getClauses()) { clause.accept(this); } return null; }
@Override public BooleanClause clone(final BooleanQuery newParent, final boolean generated) { return clone(newParent, this.occur, generated); }
Query termsToQuery(String termsQuery) { Query query = new Query(); for (String t : termsQuery.split("\\s+")) { if (t.length() > 0) { DisjunctionMaxQuery dmq = new DisjunctionMaxQuery(query, Occur.SHOULD, false); query.addClause(dmq); Term term = new Term(dmq, t); dmq.addClause(term); } } return query; }
@Override public ExpandedQuery rewrite(final ExpandedQuery query) { final QuerqyQuery<?> userQuery = query.getUserQuery(); if (userQuery != null && userQuery instanceof Query){ previousTerm = null; termsToAdd = new LinkedList<>(); visit((Query) userQuery); for (Term term : termsToAdd) { term.getParent().addClause(term); } } return query; }
BooleanQuery grandParent = null; if (parentQuery.getClauses().size() < 2) { grandParent = parentQuery.getParent(); if (grandParent.getClauses().size() < 2) { continue; parentQuery.removeClause(term); if (grandParent != null) { grandParent.removeClause(parentQuery);
@Override public Node visit(final DisjunctionMaxQuery dmq) { final List<DisjunctionMaxClause> clauses = dmq.getClauses(); if (clauses != null && !clauses.isEmpty()) { DisjunctionMaxClause nonGeneratedClause = null; for (final DisjunctionMaxClause clause: clauses) { if (!clause.isGenerated()) { // second non-generated clause - cannot handle this if (nonGeneratedClause != null) { throw new IllegalArgumentException("cannot handle more then one non-generated DMQ clause"); } nonGeneratedClause = clause; } } if (nonGeneratedClause != null) { nonGeneratedClause.accept(this); } } return null; }
@Override public BooleanClause clone(final BooleanQuery newParent) { return clone(newParent, this.occur, this.generated); }
private void addTerm(Query query, String field, String value, boolean isGenerated) { DisjunctionMaxQuery dmq = new DisjunctionMaxQuery(query, Clause.Occur.SHOULD, true); query.addClause(dmq); Term term = new Term(dmq, field, value, isGenerated); dmq.addClause(term); }
@Override public ExpandedQuery rewrite(final ExpandedQuery query) { final QuerqyQuery<?> userQuery = query.getUserQuery(); if (userQuery instanceof Query){ previousTerms = new ArrayDeque<>(); termsToDelete = new ArrayDeque<>(); nodesToAdd = new LinkedList<>(); visit((Query) userQuery); // append nodesToAdd to parent query nodesToAdd.forEach(node -> { final Node parent = node.getParent(); // TODO: extend BooleanParent? interface so that we don't need this cast? if (parent instanceof DisjunctionMaxQuery) { ((DisjunctionMaxQuery) parent).addClause((DisjunctionMaxClause) node); } else if (parent instanceof BooleanQuery) { ((BooleanQuery) parent).addClause((BooleanClause) node); } else { throw new IllegalStateException("Unknown parent type " + parent.getClass().getName()); } }); termsToDelete.forEach(this::removeIfNotOnlyChild); } return query; }
@Override public Node visit(final DisjunctionMaxQuery dmq) { final List<DisjunctionMaxClause> clauses = dmq.getClauses();
switch (status) { case TERM: { DisjunctionMaxQuery dmq = new DisjunctionMaxQuery( query, occur, false); query.addClause(dmq); Term term = new Term(dmq, input.substring(start, idx)); dmq.addClause(term); status = Status.DEFAULT; occur = Occur.SHOULD; DisjunctionMaxQuery dmq = new DisjunctionMaxQuery( query, Occur.SHOULD, false); query.addClause(dmq); Term term = new Term(dmq, occur == Occur.MUST ? "+" : "-"); dmq.addClause(term); status = Status.DEFAULT; occur = Occur.SHOULD; DisjunctionMaxQuery dmq = new DisjunctionMaxQuery(query, occur, false); query.addClause(dmq); Term term = new Term(dmq, input.substring(start)); dmq.addClause(term); DisjunctionMaxQuery dmq = new DisjunctionMaxQuery( query, Occur.SHOULD, false); query.addClause(dmq); Term term = new Term(dmq, occur == Occur.MUST ? "+"
/** * Add terms to the query for the synonyms. * * @param dmq * {@link DisjunctionMaxQuery} * @param original * Original term to determine synonyms for. */ private void addSynonyms(DisjunctionMaxQuery dmq, CharSequence original) throws IOException { try (TokenStream synonymTokens = optSynonymAnalyzer.tokenStream("querqy", new CharSequenceReader(original))) { synonymTokens.reset(); CharTermAttribute generated = synonymTokens.addAttribute(CharTermAttribute.class); while (synonymTokens.incrementToken()) { // We need to copy "generated" per toString() here, because // "generated" is transient. dmq.addClause(new Term(dmq, generated.toString(), true)); } synonymTokens.end(); } }