Java Code Examples for org.apache.lucene.search.BooleanQuery#clauses()

protected QueryBuilder convertBooleanQuery(final QueryContext context, final BooleanQuery booleanQuery, final float boost) {
    final BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    for (final BooleanClause clause : booleanQuery.clauses()) {
        final QueryBuilder queryBuilder = convertQuery(context, clause.getQuery(), boost);
        if (queryBuilder != null) {
            switch (clause.getOccur()) {
            case MUST:
                boolQuery.must(queryBuilder);
                break;
            case SHOULD:
                boolQuery.should(queryBuilder);
                break;
            case MUST_NOT:
                boolQuery.mustNot(queryBuilder);
                break;
            default:
                break;
            }
        }
    }
    if (boolQuery.hasClauses()) {
        return boolQuery;
    }
    return null;
}
 

@Override
public Query handle(Query query, QueryTransformer queryTransformer) {
    BooleanQuery booleanQuery = (BooleanQuery) query;
    boolean changed = false;
    BooleanQuery.Builder builder = new BooleanQuery.Builder();
    for (BooleanClause clause: booleanQuery.clauses()) {
        Query newClauseQuery = queryTransformer.transform(clause.getQuery());
        if (newClauseQuery != clause.getQuery()) {
            changed = true;
            builder.add(new BooleanClause(newClauseQuery, clause.getOccur()));
        } else {
            builder.add(clause);
        }
    }
    if (changed) {
        builder.setMinimumNumberShouldMatch(booleanQuery.getMinimumNumberShouldMatch());
        return builder.build();
    }
    return query;
}
 

private String findFirstGroupName(Query query) {
  if (query instanceof BooleanQuery) {
    BooleanQuery booleanQuery = (BooleanQuery) query;
    for (BooleanClause clause : booleanQuery.clauses()) {
      String groupName = findFirstGroupName(clause.getQuery());
      if (groupName != null) {
        return groupName;
      }
    }
    return null;
  } else if (query instanceof SuperQuery) {
    SuperQuery sq = (SuperQuery) query;
    return findFirstGroupName(sq.getQuery());
  } else {
    String fieldName = _fieldNames.get(query);
    return getGroupName(fieldName);
  }
}
 

public void testSeedDocumentMap_minTermFrequencySet_shouldBuildQueryAccordingToCorrectTermFrequencies() throws Exception {
  mlt.setMinTermFreq(3);

  String mltField1 = "text";
  String mltField2 = "text2";
  mlt.setFieldNames(new String[]{mltField1, mltField2});

  Map<String, Collection<Object>> seedDocument = new HashMap<>();
  String textValue = "apache apache lucene lucene lucene";
  seedDocument.put(mltField1, Arrays.asList(textValue));
  seedDocument.put(mltField2, Arrays.asList(textValue));

  BooleanQuery query = (BooleanQuery) mlt.like(seedDocument);
  Collection<BooleanClause> clauses = query.clauses();
  assertEquals("Expected 1 clauses only!", 1, clauses.size());
  for (BooleanClause clause : clauses) {
    Term term = ((TermQuery) clause.getQuery()).getTerm();
    assertThat(term, is(new Term(mltField1, "lucene")));
  }
  analyzer.close();
}
 

private boolean isSameGroupName(Query query, String groupName) {
  if (query instanceof BooleanQuery) {
    BooleanQuery booleanQuery = (BooleanQuery) query;
    for (BooleanClause clause : booleanQuery.clauses()) {
      if (!isSameGroupName(clause.getQuery(), groupName)) {
        return false;
      }
    }
    return true;
  } else {
    String fieldName = _fieldNames.get(query);
    String currentGroupName = getGroupName(fieldName);
    if (groupName.equals(currentGroupName) || isSystemField(fieldName)) {
      return true;
    }
    return false;
  }
}
 

private static void flattenBooleanQuery(BooleanQuery.Builder to, BooleanQuery from, float fromBoost) {

    for (BooleanClause clause : from.clauses()) {

      Query cq = clause.getQuery();
      float boost = fromBoost;
      while (cq instanceof BoostQuery) {
        BoostQuery bq = (BoostQuery) cq;
        cq = bq.getQuery();
        boost *= bq.getBoost();
      }

      if (cq instanceof BooleanQuery
          && !clause.isRequired()
          && !clause.isProhibited()) {

        /* we can recurse */
        flattenBooleanQuery(to, (BooleanQuery)cq, boost);

      } else {
        to.add(clause);
      }
    }
  }
 

@Test
public void testBandsWrap() throws SyntaxError {

  NamedList<Object> par = new NamedList<>();
  par.add("sim", "0.8");
  par.add("tp", "0.694");
  par.add("sep", ",");
  par.add("debug", "false");

  QParser qparser = h.getCore().getQueryPlugin("minhash").createParser("1, 2, 3, 4, 5, 6, 7, 8, 9, 10", SolrParams.toSolrParams(par), null, null);
  Query query = qparser.getQuery();

  BooleanQuery bq = (BooleanQuery)query;
  assertEquals(4, bq.clauses().size());
  for(BooleanClause clause : bq.clauses()) {
    assertEquals(3, ((BooleanQuery)((ConstantScoreQuery)clause.getQuery()).getQuery())  .clauses().size());
  }

}
 

@Override
public Query applyMinimumShouldMatch(final BooleanQuery query) {

    final List<BooleanClause> clauses = query.clauses();
    if (clauses.size() < 2) {
        return query;
    }

    for (final BooleanClause clause : clauses) {
        if ((clause.getQuery() instanceof BooleanQuery) && (clause.getOccur() != BooleanClause.Occur.MUST)) {
            return query; // seems to be a complex query with sub queries - do not
            // apply mm
        }
    }

    return SolrPluginUtils.setMinShouldMatch(query, minShouldMatch);

}
 

public static Query applyMinimumShouldMatch(BooleanQuery query, @Nullable String minimumShouldMatch) {
    if (minimumShouldMatch == null) {
        return query;
    }
    int optionalClauses = 0;
    for (BooleanClause c : query.clauses()) {
        if (c.getOccur() == BooleanClause.Occur.SHOULD) {
            optionalClauses++;
        }
    }

    int msm = calculateMinShouldMatch(optionalClauses, minimumShouldMatch);
    if (0 < msm) {
        BooleanQuery.Builder builder = new BooleanQuery.Builder();
        for (BooleanClause clause : query) {
            builder.add(clause);
        }
        builder.setMinimumNumberShouldMatch(msm);
        return builder.build();
    } else {
        return query;
    }
}
 

private Filter buildNewFilter(Query query, ConcurrentMap<String, String> filterAlias, FilterParser filterParser)
    throws ParseException {
  if (query instanceof BooleanQuery) {
    BooleanQuery booleanQuery = (BooleanQuery) query;
    BooleanFilter booleanFilter = new BooleanFilter();
    for (BooleanClause clause : booleanQuery.clauses()) {
      booleanFilter.add(buildNewFilter(clause.getQuery(), filterAlias, filterParser), clause.getOccur());
    }
    return booleanFilter;
  } else if (query instanceof TermQuery) {
    TermQuery termQuery = (TermQuery) query;
    Term term = termQuery.getTerm();
    String key = term.toString();
    String queryStr = filterAlias.get(key);
    if (queryStr == null) {
      return new QueryWrapperFilter(termQuery);
    }
    String id = getId(key);
    return new FilterCache(id, new QueryWrapperFilter(filterParser.parse(queryStr)));
  } else {
    return new QueryWrapperFilter(query);
  }
}
 

private Query fixNegatives(Query query) {
  if (query instanceof SuperQuery) {
    SuperQuery superQuery = (SuperQuery) query;
    fixNegatives(superQuery.getQuery());
  } else if (query instanceof BooleanQuery) {
    BooleanQuery booleanQuery = (BooleanQuery) query;
    for (BooleanClause clause : booleanQuery.clauses()) {
      fixNegatives(clause.getQuery());
    }
    if (containsAllNegativeQueries(booleanQuery)) {
      if (containsSuperQueries(booleanQuery)) {
        booleanQuery.add(new TermQuery(_defaultPrimeDocTerm), Occur.SHOULD);
      } else {
        booleanQuery.add(new MatchAllDocsQuery(), Occur.SHOULD);
      }
    }
  }
  return query;
}
 

@Override
public void extractSubQueriesFields(final BooleanQuery q, final Iterable<QueryExtractor<? extends Query>> extractors,
    final Set<String> extractedFields) throws UnsupportedOperationException {
  final List<BooleanClause> clauses = q.clauses();
  for (final BooleanClause clause : clauses) {
    extractFields(clause.getQuery(), extractors, extractedFields);
  }
}
 

private boolean allFieldQueriesAreSystemFields(Query query) {
  if (query instanceof BooleanQuery) {
    BooleanQuery booleanQuery = (BooleanQuery) query;
    for (BooleanClause clause : booleanQuery.clauses()) {
      if (!allFieldQueriesAreSystemFields(clause.getQuery())) {
        return false;
      }
    }
    return true;
  } else if (query instanceof SuperQuery) {
    return allFieldQueriesAreSystemFields(((SuperQuery) query).getQuery());
  } else {
    return isSystemField(_fieldNames.get(query));
  }
}
 

private boolean containsAllNegativeQueries(BooleanQuery booleanQuery) {
  for (BooleanClause clause : booleanQuery.clauses()) {
    if (clause.getOccur() == Occur.MUST || clause.getOccur() == Occur.SHOULD) {
      return false;
    }
  }
  return true;
}
 

private Query boolToExtendedCommonTermsQuery(BooleanQuery bq,
                                             Occur highFreqOccur,
                                             Occur lowFreqOccur,
                                             float maxTermFrequency) {
    ExtendedCommonTermsQuery query = new ExtendedCommonTermsQuery(highFreqOccur, lowFreqOccur, maxTermFrequency);
    for (BooleanClause clause : bq.clauses()) {
        if ((clause.getQuery() instanceof TermQuery) == false) {
            return bq;
        }
        query.add(((TermQuery) clause.getQuery()).getTerm());
    }
    return query;
}
 

@Override
public void extract(final BooleanQuery q, final Iterable<QueryExtractor<? extends Query>> extractors,
        final List<Query> extractedQueries) throws UnsupportedOperationException {
  final List<BooleanClause> clauses = q.clauses();
  for (final BooleanClause clause : clauses) {
    extractQuery(clause.getQuery(), extractors, extractedQueries);
  }
}
 

/** return true if this query has no positive components */
public static boolean isNegative(Query q) {
  if (!(q instanceof BooleanQuery)) return false;
  BooleanQuery bq = (BooleanQuery)q;
  Collection<BooleanClause> clauses = bq.clauses();
  if (clauses.size()==0) return false;
  for (BooleanClause clause : clauses) {
    if (!clause.isProhibited()) return false;
  }
  return true;
}
 

public void testMultiValues() throws Exception {
  Analyzer analyzer = new MockAnalyzer(random(), MockTokenizer.KEYWORD, false);
  mlt.setAnalyzer(analyzer);
  mlt.setFieldNames(new String[] {"text"});
  
  BooleanQuery query = (BooleanQuery) mlt.like("text",
      new StringReader("lucene"), new StringReader("lucene release"),
      new StringReader("apache"), new StringReader("apache lucene"));
  Collection<BooleanClause> clauses = query.clauses();
  assertEquals("Expected 2 clauses only!", 2, clauses.size());
  for (BooleanClause clause : clauses) {
    Term term = ((TermQuery) clause.getQuery()).getTerm();
    assertTrue(Arrays.asList(new Term("text", "lucene"), new Term("text", "apache")).contains(term));
  }
}
 

/** From org.apache.solr.search.QueryUtils **/
public static boolean isNegative(Query q) {
	if (!(q instanceof BooleanQuery))
		return false;
	BooleanQuery bq = (BooleanQuery) q;
	Collection<BooleanClause> clauses = bq.clauses();
	if (clauses.size() == 0)
		return false;
	for (BooleanClause clause : clauses) {
		if (!clause.isProhibited())
			return false;
	}
	return true;
}
 

public static void assertEqualsBooleanQuery(BooleanQuery expected, BooleanQuery actual) {
  List<BooleanClause> clauses1 = expected.clauses();
  List<BooleanClause> clauses2 = actual.clauses();
  assertEqualsBooleanClause(clauses1, clauses2);
}