Java Code Examples for org.apache.lucene.search.BooleanClause#Occur

private BooleanClause.Occur resolveClauseOccur(BooleanClause clause) {
    BooleanClause.Occur occur = clause.getOccur();
    if (negate) {
        switch (occur) {
            case SHOULD:
                occur = BooleanClause.Occur.MUST_NOT;
                break;
            case MUST:
                occur = BooleanClause.Occur.SHOULD;
                break;
            case MUST_NOT:
                occur = BooleanClause.Occur.SHOULD;
                break;
        }
    }
    return occur;
}
 

public void testStaticMethod2Old() throws QueryNodeException {
  String[] fields = { "b", "t" };
  BooleanClause.Occur[] flags = { BooleanClause.Occur.MUST,
      BooleanClause.Occur.MUST_NOT };
  StandardQueryParser parser = new StandardQueryParser();
  parser.setMultiFields(fields);
  parser.setAnalyzer(new MockAnalyzer(random()));

  Query q = QueryParserUtil.parse("one", fields, flags,
      new MockAnalyzer(random()));// , fields, flags, new
  // MockAnalyzer());
  assertEquals("+b:one -t:one", q.toString());

  q = QueryParserUtil.parse("one two", fields, flags, new MockAnalyzer(random()));
  assertEquals("+(b:one b:two) -(t:one t:two)", q.toString());

  // expected exception, array length differs
  expectThrows(IllegalArgumentException.class, () -> {
    BooleanClause.Occur[] flags2 = { BooleanClause.Occur.MUST };
    QueryParserUtil.parse("blah", fields, flags2, new MockAnalyzer(random()));
  });
}
 

public void testStaticMethod3Old() throws QueryNodeException {
  String[] queries = { "one", "two" };
  String[] fields = { "b", "t" };
  BooleanClause.Occur[] flags = { BooleanClause.Occur.MUST,
      BooleanClause.Occur.MUST_NOT };
  Query q = QueryParserUtil.parse(queries, fields, flags,
      new MockAnalyzer(random()));
  assertEquals("+b:one -t:two", q.toString());

  // expected exception, array length differs
  expectThrows(IllegalArgumentException.class, () -> {
    BooleanClause.Occur[] flags2 = { BooleanClause.Occur.MUST };
    QueryParserUtil
        .parse(queries, fields, flags2, new MockAnalyzer(random()));
  });
}
 

private Collection<Pipe> processOrClauses(Map<BooleanClause.Occur, Collection<BooleanClause>> groupedClauses) {
    Collection<BooleanClause> shouldClauses = groupedClauses.get(BooleanClause.Occur.SHOULD);
    Collection<Pipe> orPipes = new ArrayList<>();
    if (shouldClauses != null) {
        for (BooleanClause shouldClause : shouldClauses) {
            QueryExpression queryExpression = queryFactory.create(shouldClause.getQuery(), resourceDefinition);
            // don't negate expression if we negated MUST_NOT -> SHOULD
            if (negate && shouldClause.getOccur() != BooleanClause.Occur.MUST_NOT) {
                queryExpression.setNegate();
            }
            properties.addAll(queryExpression.getProperties());
            orPipes.add(queryExpression.asPipe());
        }
    }
    return orPipes;
}
 

private Collection<Pipe> processAndClauses(Map<BooleanClause.Occur, Collection<BooleanClause>> groupedClauses) {
    Collection<BooleanClause> andClauses = groupedClauses.get(BooleanClause.Occur.MUST);
    Collection<Pipe> andPipes = new ArrayList<>();
    if (andClauses != null) {
        for (BooleanClause andClause : andClauses) {
            QueryExpression queryExpression = queryFactory.create(andClause.getQuery(), resourceDefinition);
            properties.addAll(queryExpression.getProperties());
            andPipes.add(queryExpression.asPipe());
        }
    }
    return andPipes;
}
 

public static void addQueriesToBoolean(
        BooleanQuery.Builder bq,
        List<Query> queries,
        BooleanClause.Occur occur) {
  for (int i = 0; i < queries.size(); i++) {
    bq.add( queries.get(i), occur);
  }
}
 

private static BooleanQuery addClause(BooleanQuery bq, Query query, BooleanClause.Occur occur) {
  BooleanQuery.Builder newBq = new BooleanQuery.Builder();
  newBq.setMinimumNumberShouldMatch(bq.getMinimumNumberShouldMatch());
  for (BooleanClause clause : bq) {
    newBq.add(clause);
  }
  newBq.add(query, occur);
  return newBq.build();
}
 

/**
 * Makes a boolean query based upon a collection of queries and a logical operator.
 *
 * @param occur the logical operator
 * @param queries the query collection
 * @return the query
 */
BooleanQuery makeQuery(BooleanClause.Occur occur, Query... queries) {
  BooleanQuery.Builder bq = new BooleanQuery.Builder();
  for (Query query : queries) {
    if (query != null)
      bq.add(query, occur);
  }
  return bq.build();
}
 

public void testStaticMethod2() throws ParseException {
  String[] fields = {"b", "t"};
  BooleanClause.Occur[] flags = {BooleanClause.Occur.MUST, BooleanClause.Occur.MUST_NOT};
  Query q = MultiFieldQueryParser.parse("one", fields, flags, new MockAnalyzer(random()));
  assertEquals("+b:one -t:one", q.toString());

  q = MultiFieldQueryParser.parse("one two", fields, flags, new MockAnalyzer(random()));
  assertEquals("+(b:one b:two) -(t:one t:two)", q.toString());

  // expected exception, array length differs
  expectThrows(IllegalArgumentException.class, () -> {
    BooleanClause.Occur[] flags2 = {BooleanClause.Occur.MUST};
    MultiFieldQueryParser.parse("blah", fields, flags2, new MockAnalyzer(random()));
  });
}
 

private Map<BooleanClause.Occur, Collection<BooleanClause>> groupClauses() {
    Map<BooleanClause.Occur, Collection<BooleanClause>> groupedClauses = new HashMap<>();
    for (BooleanClause clause : clauses) {
        BooleanClause.Occur occur = resolveClauseOccur(clause);
        Collection<BooleanClause> clauseGrouping = groupedClauses.get(occur);
        if (clauseGrouping == null) {
            clauseGrouping = new ArrayList<>();
            groupedClauses.put(occur, clauseGrouping);
        }
        clauseGrouping.add(clause);
    }
    return groupedClauses;
}
 

/**
 *
 * @param pq PhraseQuery to break up and convert to NGramQuery
 * Forms a BooleanQuery with each term in the original PhraseQuery OR'd.
 * Note:  Assumes that each term has already been tokenized into a ngram,
 * this method will not re-tokenize terms.
 * @param useMust controls if BooleanClause.Occur SHOULD or MUST is used.
 */
public NGramQuery(PhraseQuery pq, boolean useMust) {
    Term[] terms = pq.getTerms();
    for (int i = 0; i < terms.length; i++) {
        BooleanClause.Occur occur = BooleanClause.Occur.SHOULD;
        if (useMust) {
            occur = BooleanClause.Occur.MUST;
        }
        add(new TermQuery(terms[i]), occur);
    }
}
 

/**
 * Constructs a query to retrieve documents that fully contain the input envelope.
 */
private Query makeWithin(Rectangle bbox) {
  BooleanQuery.Builder bq = new BooleanQuery.Builder();
  BooleanClause.Occur MUST = BooleanClause.Occur.MUST;
  if (bbox.getCrossesDateLine()) {
    //use null as performance trick since no data will be beyond the world bounds
    bq.add(rangeQuery(fieldNameX, null/*-180*/, bbox.getMaxX()), BooleanClause.Occur.SHOULD );
    bq.add(rangeQuery(fieldNameX, bbox.getMinX(), null/*+180*/), BooleanClause.Occur.SHOULD );
    bq.setMinimumNumberShouldMatch(1);//must match at least one of the SHOULD
  } else {
    bq.add(rangeQuery(fieldNameX, bbox.getMinX(), bbox.getMaxX()), MUST);
  }
  bq.add(rangeQuery(fieldNameY, bbox.getMinY(), bbox.getMaxY()), MUST);
  return bq.build();
}
 

private Collection<Pipe> processNotClauses(Map<BooleanClause.Occur, Collection<BooleanClause>> groupedClauses) {
    Collection<BooleanClause> notClauses = groupedClauses.get(BooleanClause.Occur.MUST_NOT);
    Collection<Pipe> notPipes = new ArrayList<>();
    if (notClauses != null) {
        for (BooleanClause notClause : notClauses) {
            QueryExpression queryExpression = queryFactory.create(notClause.getQuery(), resourceDefinition);
            queryExpression.setNegate();
            properties.addAll(queryExpression.getProperties());
            notPipes.add(queryExpression.asPipe());
        }
    }
    return notPipes;
}
 

@Override
public QueryVisitor getSubVisitor(BooleanClause.Occur occur, Query parent) {
  if (lookInSpan == false && parent instanceof SpanQuery) {
    return QueryVisitor.EMPTY_VISITOR;
  }
  return super.getSubVisitor(occur, parent);
}
 

@Override
public QueryVisitor getSubVisitor(BooleanClause.Occur occur, Query parent) {
  if (parent instanceof BoostQuery) {
    float newboost = boost * ((BoostQuery)parent).getBoost();
    return new BoostedTermExtractor(newboost, terms, includeProhibited, fieldSelector);
  }
  if (occur == BooleanClause.Occur.MUST_NOT && includeProhibited == false) {
    return QueryVisitor.EMPTY_VISITOR;
  }
  return this;
}
 

/**
 * Creates a query from a token stream.
 *
 * @param source     the token stream to create the query from
 * @param operator   default boolean operator used for this query
 * @param field      field to create queries against
 * @param quoted     true if phrases should be generated when terms occur at more than one position
 * @param phraseSlop slop factor for phrase/multiphrase queries
 */
protected Query createFieldQuery(TokenStream source, BooleanClause.Occur operator, String field, boolean quoted, int phraseSlop) {
  assert operator == BooleanClause.Occur.SHOULD || operator == BooleanClause.Occur.MUST;

  // Build an appropriate query based on the analysis chain.
  try (CachingTokenFilter stream = new CachingTokenFilter(source)) {
    
    TermToBytesRefAttribute termAtt = stream.getAttribute(TermToBytesRefAttribute.class);
    PositionIncrementAttribute posIncAtt = stream.addAttribute(PositionIncrementAttribute.class);
    PositionLengthAttribute posLenAtt = stream.addAttribute(PositionLengthAttribute.class);

    if (termAtt == null) {
      return null; 
    }
    
    // phase 1: read through the stream and assess the situation:
    // counting the number of tokens/positions and marking if we have any synonyms.
    
    int numTokens = 0;
    int positionCount = 0;
    boolean hasSynonyms = false;
    boolean isGraph = false;

    stream.reset();
    while (stream.incrementToken()) {
      numTokens++;
      int positionIncrement = posIncAtt.getPositionIncrement();
      if (positionIncrement != 0) {
        positionCount += positionIncrement;
      } else {
        hasSynonyms = true;
      }

      int positionLength = posLenAtt.getPositionLength();
      if (enableGraphQueries && positionLength > 1) {
        isGraph = true;
      }
    }
    
    // phase 2: based on token count, presence of synonyms, and options
    // formulate a single term, boolean, or phrase.
    
    if (numTokens == 0) {
      return null;
    } else if (numTokens == 1) {
      // single term
      return analyzeTerm(field, stream);
    } else if (isGraph) {
      // graph
      if (quoted) {
        return analyzeGraphPhrase(stream, field, phraseSlop);
      } else {
        return analyzeGraphBoolean(field, stream, operator);
      }
    } else if (quoted && positionCount > 1) {
      // phrase
      if (hasSynonyms) {
        // complex phrase with synonyms
        return analyzeMultiPhrase(field, stream, phraseSlop);
      } else {
        // simple phrase
        return analyzePhrase(field, stream, phraseSlop);
      }
    } else {
      // boolean
      if (positionCount == 1) {
        // only one position, with synonyms
        return analyzeBoolean(field, stream);
      } else {
        // complex case: multiple positions
        return analyzeMultiBoolean(field, stream, operator);
      }
    }
  } catch (IOException e) {
    throw new RuntimeException("Error analyzing query text", e);
  }
}
 

public void setOccur(BooleanClause.Occur occur) {
    this.occur = occur;
}
 

/** Retrieve suggestions, specifying whether all terms
 *  must match ({@code allTermsRequired}) and whether the hits
 *  should be highlighted ({@code doHighlight}). */
public List<LookupResult> lookup(CharSequence key, Map<BytesRef, BooleanClause.Occur> contextInfo, int num, boolean allTermsRequired, boolean doHighlight) throws IOException {
    return lookup(key, toQuery(contextInfo), num, allTermsRequired, doHighlight);
}
 

/**
 * Creates a boolean query from a graph token stream. The articulation points of the graph are visited in order and the queries
 * created at each point are merged in the returned boolean query.
 */
protected Query analyzeGraphBoolean(String field, TokenStream source, BooleanClause.Occur operator) throws IOException {
  source.reset();
  GraphTokenStreamFiniteStrings graph = new GraphTokenStreamFiniteStrings(source);
  BooleanQuery.Builder builder = new BooleanQuery.Builder();
  int[] articulationPoints = graph.articulationPoints();
  int lastState = 0;
  for (int i = 0; i <= articulationPoints.length; i++) {
    int start = lastState;
    int end = -1;
    if (i < articulationPoints.length) {
      end = articulationPoints[i];
    }
    lastState = end;
    final Query positionalQuery;
    if (graph.hasSidePath(start)) {
      final Iterator<TokenStream> sidePathsIterator = graph.getFiniteStrings(start, end);
      Iterator<Query> queries = new Iterator<Query>() {
        @Override
        public boolean hasNext() {
          return sidePathsIterator.hasNext();
        }

        @Override
        public Query next() {
          TokenStream sidePath = sidePathsIterator.next();
          return createFieldQuery(sidePath, BooleanClause.Occur.MUST, field, getAutoGenerateMultiTermSynonymsPhraseQuery(), 0);
        }
      };
      positionalQuery = newGraphSynonymQuery(queries);
    } else {
      List<AttributeSource> attributes = graph.getTerms(start);
      TermAndBoost[] terms = attributes.stream()
              .map(s -> {
                TermToBytesRefAttribute t = s.addAttribute(TermToBytesRefAttribute.class);
                BoostAttribute b = s.addAttribute(BoostAttribute.class);
                return new TermAndBoost(new Term(field, t.getBytesRef()), b.getBoost());
              })
              .toArray(TermAndBoost[]::new);
      assert terms.length > 0;
      if (terms.length == 1) {
        positionalQuery = newTermQuery(terms[0].term, terms[0].boost);
      } else {
        positionalQuery = newSynonymQuery(terms);
      }
    }
    if (positionalQuery != null) {
      builder.add(positionalQuery, operator);
    }
  }
  return builder.build();
}
 

private Query createCompositeQuery(List<Query> queries, boolean orCondition) {

        BooleanClause.Occur clause = orCondition
            ? BooleanClause.Occur.SHOULD : BooleanClause.Occur.MUST;

        BooleanQuery.Builder builder = new BooleanQuery.Builder();

        for (Query query : queries) {
            builder.add(query, clause);
        }

        return builder.build();
    }