Example usage for org.apache.lucene.search BooleanClause isProhibited

Introduction

In this page you can find the example usage for org.apache.lucene.search BooleanClause isProhibited.

Prototype

public boolean isProhibited() 

Source Link

Usage

From source file:com.browseengine.bobo.search.section.SectionSearchQueryPlanBuilder.java

License:Apache License

private SectionSearchQueryPlan translateBooleanQuery(BooleanQuery query) throws IOException {
    ArrayList<Query> requiredClauses = new ArrayList<Query>();
    ArrayList<Query> prohibitedClauses = new ArrayList<Query>();
    ArrayList<Query> optionalClauses = new ArrayList<Query>();
    BooleanClause[] clauses = query.getClauses();
    for (BooleanClause clause : clauses) {
        if (clause.isRequired()) {
            requiredClauses.add(clause.getQuery());
        } else if (clause.isProhibited()) {
            prohibitedClauses.add(clause.getQuery());
        } else {/*from  www  .  j a va  2s.c  o m*/
            optionalClauses.add(clause.getQuery());
        }
    }

    SectionSearchQueryPlan positiveNode = null;
    SectionSearchQueryPlan negativeNode = null;

    if (requiredClauses.size() > 0) {
        if (requiredClauses.size() == 1) {
            positiveNode = translate(requiredClauses.get(0));
        } else {
            SectionSearchQueryPlan[] subqueries = translate(requiredClauses);
            if (subqueries != null && subqueries.length > 0)
                positiveNode = new AndNode(subqueries);
        }
    } else if (optionalClauses.size() > 0) {
        if (optionalClauses.size() == 1) {
            positiveNode = translate(optionalClauses.get(0));
        } else {
            SectionSearchQueryPlan[] subqueries = translate(optionalClauses);
            if (subqueries != null && subqueries.length > 0)
                positiveNode = new OrNode(subqueries);
        }
    }

    if (prohibitedClauses.size() > 0) {
        if (prohibitedClauses.size() == 1) {
            negativeNode = translate(prohibitedClauses.get(0));
        } else {
            negativeNode = new OrNode(translate(prohibitedClauses));
        }
    }

    if (negativeNode == null) {
        return positiveNode;
    } else {
        if (positiveNode == null) {
            return new UnaryNotNode(negativeNode);
        } else {
            return new AndNotNode(positiveNode, negativeNode);
        }
    }
}

---

From source file:com.flaptor.indextank.query.IndexEngineParser.java

License:Apache License

private QueryNode internalParseBooleanQuery(List<BooleanClause> list, final String originalStr)
        throws ParseException {
    Preconditions.checkArgument(list.size() > 0, "too few terms to build a boolean query");
    List<BooleanClause> positiveClauses = new ArrayList<BooleanClause>();
    List<BooleanClause> negativeClauses = new ArrayList<BooleanClause>();
    for (BooleanClause clause : list) {
        if (clause.isProhibited()) {
            negativeClauses.add(clause);
        } else {/*from  w  w w  . j  a v a  2s  . c o m*/
            positiveClauses.add(clause);
        }
    }
    if (positiveClauses.isEmpty()) {
        throw new ParseException("No positive clauses.");
    }
    QueryNode retVal = internalParsePositive(positiveClauses, originalStr);

    for (BooleanClause clause : negativeClauses) {
        retVal = new DifferenceQuery(retVal, internalParse(clause.getQuery(), null));
    }
    return retVal;
}

---

From source file:com.o19s.solr.swan.highlight.SpanAwareFieldQuery.java

License:Apache License

void flatten(Query sourceQuery, IndexReader reader, Collection<Query> flatQueries) throws IOException {
    if (sourceQuery instanceof BooleanQuery) {
        BooleanQuery bq = (BooleanQuery) sourceQuery;
        for (BooleanClause clause : bq.getClauses()) {
            if (!clause.isProhibited())
                flatten(clause.getQuery(), reader, flatQueries);
        }/*w  ww. j a v a2  s .co  m*/
    } else if (sourceQuery instanceof DisjunctionMaxQuery) {
        DisjunctionMaxQuery dmq = (DisjunctionMaxQuery) sourceQuery;
        for (Query query : dmq) {
            flatten(query, reader, flatQueries);
        }
    } else if (sourceQuery instanceof TermQuery) {
        if (!flatQueries.contains(sourceQuery))
            flatQueries.add(sourceQuery);
    } else if (sourceQuery instanceof MultiTermQuery && reader != null) {
        MultiTermQuery copy = (MultiTermQuery) sourceQuery.clone();
        copy.setRewriteMethod(new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(MAX_MTQ_TERMS));
        BooleanQuery mtqTerms = (BooleanQuery) copy.rewrite(reader);
        flatten(mtqTerms, reader, flatQueries);
    } else if (sourceQuery instanceof PhraseQuery) {
        if (!flatQueries.contains(sourceQuery)) {
            PhraseQuery pq = (PhraseQuery) sourceQuery;
            if (pq.getTerms().length > 1)
                flatQueries.add(pq);
            else if (pq.getTerms().length == 1) {
                flatQueries.add(new TermQuery(pq.getTerms()[0]));
            }
        }
    } else if (sourceQuery instanceof SpanQuery) {
        //TODO Note that the way we are doing phrases, they become SpanQueries - thus we loose
        //all of the corner case fixes for the phrases already in highlighing - the result will be
        //phrases that have different color highlights for each term
        Set<Term> terms = new LinkedHashSet<Term>();
        List<AtomicReaderContext> readerContexts = reader.getContext().leaves();

        int offset = 0;

        if (readerContexts.size() < 1) {
            return;
        }
        for (AtomicReaderContext arc : readerContexts) {
            if (sourceQuery instanceof SpanNotQuery) {
                SpanNotQuery query = (SpanNotQuery) sourceQuery;
                addSpansPositions(offset, query.getField(),
                        query.getInclude().getSpans(arc, null, new HashMap<Term, TermContext>()));
            } else {
                SpanQuery query = (SpanQuery) sourceQuery;
                addSpansPositions(offset, query.getField(),
                        query.getSpans(arc, null, new HashMap<Term, TermContext>()));
            }
            offset += arc.reader().maxDoc();
        }

        //TODO it is necessary to call getSpans first so that if there is a MultiTerm query it get's rewritten by com.o19s.solr.swan.nodes.SwanTermNode.SwanSpanMultiTermQueryWrapper
        //no easy way around this
        sourceQuery.extractTerms(terms);
        for (Term t : terms) {
            flatQueries.add(new SpanTermQuery(t));//TODO need to check that this isn't already in the flatQueries (see example above)
        }

    }
    // else discard queries
}

---

From source file:de.hybris.platform.solr.search.MultiMaxScoreQParser.java

License:Open Source License

@Override
public Query parse() throws SyntaxError {
    final Query q = super.parse();

    if (!(q instanceof BooleanQuery)) {
        return q;
    }// w w  w.j  a  v  a 2s  .c o m

    final BooleanQuery oldQuery = (BooleanQuery) q;
    final BooleanQuery.Builder newQuery = new BooleanQuery.Builder();

    List<Query> disjuncts = null;

    for (final BooleanClause clause : oldQuery.clauses()) {
        if (clause.isProhibited() || clause.isRequired()) {
            newQuery.add(clause);
        } else {
            final Query subQuery = clause.getQuery();
            if (!(subQuery instanceof BooleanQuery)) {
                if (disjuncts == null) {
                    disjuncts = new ArrayList<>();
                }

                disjuncts.add(clause.getQuery());
            } else {
                final List<Query> subQueriesList = new ArrayList<>();
                for (final BooleanClause subQueryClause : ((BooleanQuery) subQuery).clauses()) {
                    subQueriesList.add(subQueryClause.getQuery());
                }
                final DisjunctionMaxQuery subDmq = new DisjunctionMaxQuery(subQueriesList, tie);
                newQuery.add(subDmq, BooleanClause.Occur.SHOULD);
            }
        }
    }

    if (CollectionUtils.isNotEmpty(disjuncts)) {
        final DisjunctionMaxQuery disjunctionQuery = new DisjunctionMaxQuery(disjuncts, tie);
        newQuery.add(disjunctionQuery, BooleanClause.Occur.SHOULD);
    }

    return newQuery.build();
}

---

From source file:de.joergjahnke.jdesktopsearch.abstractionlayer.SQLServerIndexManager.java

License:Open Source License

/**
 * Get SQL queries' WHERE-clause/*  ww  w  .ja  v a2s.c  om*/
 *
 * @param   query   Lucene query to translate into a SQL WHERE-clause
 * @param   logicalOperator logical operator to use when connecting the results of the query to an existing WHERE-clause
 * @param   termQuery   SQL query fragment to use
 * @return  list of strings where the first entry is an SQL query that can be used in a PreparedStatement. The following
 *          strings are to be set as parameters for this PreparedStatement.
 */
private WhereClauseParameters getSQLWhereClause(final Query query, String logicalOperator,
        final String termQuery) {
    if (DEBUG)
        System.err.println(this.getClass().getName() + ": Query-Class: " + query.getClass());
    if (DEBUG)
        System.err.println(this.getClass().getName() + ": Query: " + query);

    final List<String> params = new LinkedList<String>();
    final StringBuffer sql = new StringBuffer();

    // process BooleanQuerys
    // these contain of two subqueries which have to be connected by a logical operator
    if (query instanceof BooleanQuery) {
        boolean brackedOpened = false;
        final List<String> sqlList = new LinkedList<String>();
        final List<Collection<String>> paramsList = new LinkedList<Collection<String>>();

        for (BooleanClause clause : ((BooleanQuery) query).getClauses()) {
            if (DEBUG)
                System.err.println(this.getClass().getName() + ": BooleanClause: p: " + clause.isProhibited()
                        + ", r:  " + clause.isRequired());

            if (clause.isProhibited()) {
                if (!"AND NOT".equals(logicalOperator)) {
                    sql.append(" " + logicalOperator + " NOT ( 1=1");
                    brackedOpened = true;
                    appendToWhereClause(sqlList, paramsList, sql, params);
                }

                final WhereClauseParameters subQuery = getSQLWhereClause(clause.getQuery(), "AND", termQuery);

                sqlList.add(subQuery.getSQL());
                paramsList.add(subQuery.getParameters());

                logicalOperator = "AND NOT";
            } else if (clause.isRequired()) {
                if (!"AND".equals(logicalOperator)) {
                    sql.append(" " + logicalOperator + " ( 1=1");
                    brackedOpened = true;
                    appendToWhereClause(sqlList, paramsList, sql, params);
                }

                final WhereClauseParameters subQuery = getSQLWhereClause(clause.getQuery(), "AND", termQuery);

                sqlList.add(subQuery.getSQL());
                paramsList.add(subQuery.getParameters());

                logicalOperator = "AND";
            } else {
                if (!"OR".equals(logicalOperator)) {
                    sql.append(" " + logicalOperator + " ( 1=2");
                    brackedOpened = true;
                    appendToWhereClause(sqlList, paramsList, sql, params);
                }

                final WhereClauseParameters subQuery = getSQLWhereClause(clause.getQuery(), "OR", termQuery);

                sqlList.add(subQuery.getSQL());
                paramsList.add(subQuery.getParameters());

                logicalOperator = "OR";
            }
        }

        // not all parts of the query has already been added
        if (!sqlList.isEmpty()) {
            if ("OR".equals(logicalOperator)) {
                optimizeQuery(sqlList, paramsList);
            }

            if (DEBUG)
                System.err.println(this.getClass().getName() + ": AfterOptimization: New SQL= " + sql);
            if (DEBUG)
                System.err
                        .println(this.getClass().getName() + ": AfterOptimization: New Parameters= " + params);

            // then add the rest
            appendToWhereClause(sqlList, paramsList, sql, params);

            if (DEBUG)
                System.err.println(this.getClass().getName() + ": AfterOptimization: New SQL= " + sql);
            if (DEBUG)
                System.err
                        .println(this.getClass().getName() + ": AfterOptimization: New Parameters= " + params);
        }

        // a bracket has been opened
        if (brackedOpened) {
            // then only close the bracket
            sql.append(" )");
        }
        // process TermQuery, WildCardQuery or PrefixQuery
        // these contain a single term which needs to be matched and may contain one or more wildcards
    } else if (query instanceof TermQuery || query instanceof WildcardQuery || query instanceof PrefixQuery) {
        processTermQuery(sql, params, query, logicalOperator, termQuery);
        // process PhraseQuery
        // such a query contains a set phrase
    } else if (query instanceof PhraseQuery) {
        processPhraseQuery(sql, params, query, logicalOperator, termQuery);
        // process RangeQuery
        // such a query contains an upper and lower boundary wherein the results may lie
    } else if (query instanceof RangeQuery) {
        processRangeQuery(sql, params, query, logicalOperator, termQuery);
    } else {
        throw new RuntimeException("Query type '" + query.getClass() + "' not supported!");
    }

    if (DEBUG)
        System.err.println(this.getClass().getName() + ": SQL= " + sql);
    if (DEBUG)
        System.err.println(this.getClass().getName() + ": Params= " + params);

    return new WhereClauseParameters(sql.toString(), params);
}

---

From source file:de.joergjahnke.jdesktopsearch.QueryUtils.java

License:Open Source License

/**
 * Get search terms for a given field from a query
 *
 * @param   query   query to analyze//from w  ww. j  a  v a2s . c o  m
 * @param   fieldName   fieldName for which terms are searched
 * @return  set of search terms
 */
public static Set<String> getSearchTerms(final Query query, final String fieldName) {
    final Set<String> result = new HashSet<String>();

    // analyze the sub-queries of BooleanQuerys
    if (query instanceof BooleanQuery) {
        final BooleanClause[] clauses = ((BooleanQuery) query).getClauses();

        for (BooleanClause clause : clauses) {
            if (!clause.isProhibited()) {
                result.addAll(getSearchTerms(clause.getQuery(), fieldName));
            }
        }
        // extract terms from TermQuerys
    } else if (query instanceof TermQuery) {
        final Term term = ((TermQuery) query).getTerm();

        if (term.field().equals(fieldName)) {
            result.add(term.text());
        }
    }

    return result;
}

---

From source file:de.unioninvestment.eai.portal.portlet.crud.domain.model.CompoundSearch.java

License:Apache License

private List<Filter> convertBooleanClauses(Table table, BooleanQuery booleanQuery,
        boolean ignorePartialErrors) {
    List<Filter> subList = new ArrayList<Filter>(booleanQuery.getClauses().length);
    List<RuntimeException> errors = new LinkedList<RuntimeException>();
    for (BooleanClause clause : booleanQuery.clauses()) {
        try {/*from www  .jav  a  2s .co  m*/
            Filter subFilter = getFiltersForTable(table, clause.getQuery());
            if (subFilter != null) {
                if (clause.isProhibited()) {
                    subFilter = new Not(asList(subFilter));
                }
                subList.add(subFilter);
            }
        } catch (RuntimeException e) {
            errors.add(e);
        }
    }
    if (ignorePartialErrors) {
        if (errors.size() < booleanQuery.clauses().size()) {
            for (RuntimeException e : errors) {
                LOGGER.info("Ignoring error in 'OR' clause: " + e.getMessage());
            }
            return subList;
        }
    }
    if (errors.size() > 0) {
        throw errors.get(0);
    }
    return subList;
}

---

From source file:it.unibz.instasearch.indexing.querying.PhraseSearcher.java

License:Open Source License

@Override
public BooleanQuery visit(BooleanQuery boolQuery) {
    PhraseQuery phraseQuery = new PhraseQuery();

    for (BooleanClause clause : boolQuery.getClauses()) {
        if (clause.isProhibited() || !clause.isRequired() || !(clause.getQuery() instanceof TermQuery))
            return super.visit(boolQuery); // only consider required terms

        TermQuery tq = (TermQuery) clause.getQuery();

        Field field = Field.getByName(tq.getTerm().field());
        if (field != Field.CONTENTS)
            continue;

        phraseQuery.add(tq.getTerm());/*from   w  ww.  ja v  a2 s  . c  o m*/
    }

    phraseQuery.setSlop(DEFAULT_SLOP);

    BooleanQuery bq = new BooleanQuery();
    bq.add(phraseQuery, Occur.SHOULD);
    bq.add(boolQuery, Occur.SHOULD);
    bq.setBoost(boolQuery.getBoost());

    phraseQuery.setBoost(boolQuery.getBoost());
    boolQuery.setBoost(phraseQuery.getBoost() * 0.5f);

    return bq;
}

---

From source file:jp.scaleout.elasticsearch.plugins.queryparser.classic.QueryParserBase.java

License:Apache License

protected void addClause(List<BooleanClause> clauses, int conj, int mods, Query q) {
    boolean required, prohibited;

    // If this term is introduced by AND, make the preceding term required,
    // unless it's already prohibited
    if (clauses.size() > 0 && conj == CONJ_AND) {
        BooleanClause c = clauses.get(clauses.size() - 1);
        if (!c.isProhibited())
            c.setOccur(BooleanClause.Occur.MUST);
    }//from www .ja va  2  s. com

    if (clauses.size() > 0 && operator == AND_OPERATOR && conj == CONJ_OR) {
        // If this term is introduced by OR, make the preceding term optional,
        // unless it's prohibited (that means we leave -a OR b but +a OR b-->a OR b)
        // notice if the input is a OR b, first term is parsed as required; without
        // this modification a OR b would parsed as +a OR b
        BooleanClause c = clauses.get(clauses.size() - 1);
        if (!c.isProhibited())
            c.setOccur(BooleanClause.Occur.SHOULD);
    }

    // We might have been passed a null query; the term might have been
    // filtered away by the analyzer.
    if (q == null)
        return;

    if (operator == OR_OPERATOR) {
        // We set REQUIRED if we're introduced by AND or +; PROHIBITED if
        // introduced by NOT or -; make sure not to set both.
        prohibited = (mods == MOD_NOT);
        required = (mods == MOD_REQ);
        if (conj == CONJ_AND && !prohibited) {
            required = true;
        }
    } else {
        // We set PROHIBITED if we're introduced by NOT or -; We set REQUIRED
        // if not PROHIBITED and not introduced by OR
        prohibited = (mods == MOD_NOT);
        required = (!prohibited && conj != CONJ_OR);
    }
    if (required && !prohibited)
        clauses.add(newBooleanClause(q, BooleanClause.Occur.MUST));
    else if (!required && !prohibited)
        clauses.add(newBooleanClause(q, BooleanClause.Occur.SHOULD));
    else if (!required && prohibited)
        clauses.add(newBooleanClause(q, BooleanClause.Occur.MUST_NOT));
    else
        throw new RuntimeException("Clause cannot be both required and prohibited");
}

---

From source file:net.lucenews.model.DidYouMeanQueryGenerator.java

License:Apache License

/**
 * Recursive extraction of the BooleanQuery in order to find all TermQuery's.
 * Returns a list sorted from greatest boost to least
 * //from   w  w  w .  j ava 2s .  com
 * @param bq
 * @param useFreqCount
 * @param useDefaultBoost
 */

private List<BooleanQuery> recursiveExtract(BooleanQuery bq, boolean useFreqCount, boolean useDefaultBoost)
        throws IOException {
    BooleanClause[] clauses = bq.getClauses();
    List<BooleanQuery> returnQueries = new ArrayList<BooleanQuery>();
    Query[][] queries = new Query[clauses.length][];

    for (int i = 0; i < clauses.length; i++) {
        BooleanClause clause = clauses[i];

        queries[i] = new Query[0];

        if (!clause.isProhibited() && clause.getQuery() instanceof BooleanQuery)
            queries[i] = recursiveExtract((BooleanQuery) clause.getQuery(), useFreqCount, useDefaultBoost)
                    .toArray(new Query[] {});

        if (!clause.isProhibited() && clause.getQuery() instanceof TermQuery)
            queries[i] = getBetterTermQueries((TermQuery) clause.getQuery(), useFreqCount, useDefaultBoost)
                    .toArray(new Query[] {});
    }

    int[] indices = new int[queries.length];

    while (indices[0] <= queries[0].length) {

        BooleanQuery returnQuery = null;
        if (bq instanceof ExpandedTermQuery) {
            returnQuery = new ExpandedTermQuery();
        } else {
            returnQuery = new BooleanQuery();
        }

        boolean addThis = true;
        for (int i = 0; i < indices.length; i++) {
            int j = indices[i];
            if (queries[i].length > 0 && queries[i].length > j) {
                Query query = queries[i][j];
                returnQuery.add(query, clauses[i].getOccur());
                addThis = true;
            } else {
                addThis = false;
                break;
            }
        }

        if (addThis)
            returnQueries.add(returnQuery);

        // Increment
        int i = indices.length - 1;
        indices[i]++;
        while (i > 0 && indices[i] >= queries[i].length) {
            indices[i] = 0;
            indices[--i]++;
        }
    }

    return returnQueries;
}

---

• «
• 1
• 2
• 3
• 4
• »