Refine search
BooleanQuery.Builder builder = new BooleanQuery.Builder(); String pkey = Token.getKeyForClass(PatternsAnnotations.ProcessedTextAnnotation.class); for(String en2: en.getValue()){ if(!processedKey || !stopWords.contains(en2.toLowerCase())) builder.add(new BooleanClause(new TermQuery(new Term(en.getKey(), en2)), BooleanClause.Occur.MUST)); BooleanQuery query = builder.build(); TopDocs tp = searcher.search(query, Integer.MAX_VALUE); Set<String> sentids = new HashSet<>(); if (tp.totalHits > 0) { for (ScoreDoc s : tp.scoreDocs) { int docId = s.doc; Document d = searcher.doc(docId);
private BooleanQuery rewriteNoScoring() { if (clauseSets.get(Occur.MUST).size() == 0) { return this; } BooleanQuery.Builder newQuery = new BooleanQuery.Builder(); newQuery.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch()); for (BooleanClause clause : clauses) { if (clause.getOccur() == Occur.MUST) { newQuery.add(clause.getQuery(), Occur.FILTER); } else { newQuery.add(clause); } } return newQuery.build(); }
public static Query newRangeSeekByStringQuery( String lower, boolean includeLower, String upper, boolean includeUpper ) { boolean includeLowerBoundary = StringUtils.EMPTY.equals( lower ) || includeLower; boolean includeUpperBoundary = StringUtils.EMPTY.equals( upper ) || includeUpper; TermRangeQuery termRangeQuery = TermRangeQuery.newStringRange( ValueEncoding.String.key( 0 ), lower, upper, includeLowerBoundary, includeUpperBoundary ); if ( (includeLowerBoundary != includeLower) || (includeUpperBoundary != includeUpper) ) { BooleanQuery.Builder builder = new BooleanQuery.Builder(); builder.setDisableCoord(true); if ( includeLowerBoundary != includeLower ) { builder.add( new TermQuery( new Term( ValueEncoding.String.key( 0 ), lower ) ), BooleanClause.Occur.MUST_NOT ); } if ( includeUpperBoundary != includeUpper ) { builder.add( new TermQuery( new Term( ValueEncoding.String.key( 0 ), upper ) ), BooleanClause.Occur.MUST_NOT ); } builder.add( termRangeQuery, BooleanClause.Occur.FILTER ); return new ConstantScoreQuery( builder.build() ); } return termRangeQuery; }
private ImageSearchHits search(String[] hashes, GlobalFeature queryFeature, IndexReader reader) throws IOException { IndexSearcher searcher = new IndexSearcher(reader); searcher.setSimilarity(new BaseSimilarity()); BooleanQuery query = null; BooleanQuery.Builder builder = new BooleanQuery.Builder(); for (int i = 0; i < hashes.length; i++) { builder.add(new BooleanClause(new TermQuery(new Term(hashesFieldName, hashes[i] + "")), BooleanClause.Occur.SHOULD)); } else builder.add(new BooleanClause(new TermQuery(new Term(hashesFieldName, hashes[i] + "")), BooleanClause.Occur.SHOULD)); query = builder.build(); TopDocs docs = searcher.search(query, maxResultsHashBased);
@Override public int getNumberOfIndexedEntities(String entity) { Class<?> clazz = getEntityClass( entity ); IndexReader indexReader = extendedIntegrator.getIndexReaderAccessor().open( clazz ); try { IndexSearcher searcher = new IndexSearcher( indexReader ); BooleanQuery boolQuery = new BooleanQuery.Builder() .add( new MatchAllDocsQuery(), BooleanClause.Occur.FILTER ) .add( new TermQuery( new Term( ProjectionConstants.OBJECT_CLASS, entity ) ), BooleanClause.Occur.FILTER ) .build(); try { TopDocs topdocs = searcher.search( boolQuery, 1 ); return topdocs.totalHits; } catch (IOException e) { throw new SearchException( "Unable to execute count query for entity " + entity, e ); } } finally { extendedIntegrator.getIndexReaderAccessor().close( indexReader ); } }
/** * Add a clause to a boolean query. */ private static void add(BooleanQuery.Builder q, String name, String value) { q.add(new BooleanClause(new TermQuery(new Term(name, value)), BooleanClause.Occur.SHOULD)); }
private TopDocs knnSearch(String text) throws IOException { BooleanQuery.Builder mltQuery = new BooleanQuery.Builder(); for (String fieldName : textFieldNames) { String boost = null; mlt.setBoost(true); //terms boost actually helps in MLT queries if (fieldName.contains("^")) { String[] field2boost = fieldName.split("\\^"); fieldName = field2boost[0]; boost = field2boost[1]; } if (boost != null) { mlt.setBoostFactor(Float.parseFloat(boost));//if we have a field boost, we add it } mltQuery.add(new BooleanClause(mlt.like(fieldName, new StringReader(text)), BooleanClause.Occur.SHOULD)); mlt.setBoostFactor(1);// restore neutral boost for next field } Query classFieldQuery = new WildcardQuery(new Term(classFieldName, "*")); mltQuery.add(new BooleanClause(classFieldQuery, BooleanClause.Occur.MUST)); if (query != null) { mltQuery.add(query, BooleanClause.Occur.MUST); } return indexSearcher.search(mltQuery.build(), k); }
@Override public Query rewrite(IndexReader reader) throws IOException { final int threshold = Math.min(BOOLEAN_REWRITE_TERM_COUNT_THRESHOLD, BooleanQuery.getMaxClauseCount()); if (termData.size() <= threshold) { BooleanQuery.Builder bq = new BooleanQuery.Builder(); TermIterator iterator = termData.iterator(); for (BytesRef term = iterator.next(); term != null; term = iterator.next()) { bq.add(new TermQuery(new Term(iterator.field(), BytesRef.deepCopyOf(term))), Occur.SHOULD); } return new ConstantScoreQuery(bq.build()); } return super.rewrite(reader); }
private Query injectOrphans( Query query ) { if ( query instanceof BooleanQuery ) { BooleanQuery source = (BooleanQuery) query; BooleanQuery.Builder builder = new BooleanQuery.Builder(); for ( BooleanClause clause : source.clauses() ) { builder.add( injectOrphans( clause.getQuery() ), clause.getOccur() ); } return builder.build(); } String orphanField = extractTermField( query ); if ( orphanField == null ) { return query; } return new BooleanQuery.Builder() .add( query, Occur.SHOULD ) .add( new TermQuery( new Term( ORPHANS_KEY, orphanField ) ), Occur.SHOULD ) .build(); }
final int threshold = Math.min(BOOLEAN_REWRITE_TERM_COUNT_THRESHOLD, BooleanQuery.getMaxClauseCount()); assert termData.size() > threshold : "Query should have been rewritten"; List<TermAndState> matchingTerms = new ArrayList<>(threshold); BooleanQuery.Builder bq = new BooleanQuery.Builder(); for (TermAndState t : matchingTerms) { final TermContext termContext = new TermContext(searcher.getTopReaderContext()); termContext.register(t.state, context.ord, t.docFreq, t.totalTermFreq); bq.add(new TermQuery(new Term(t.field, t.term), termContext), Occur.SHOULD); Query q = new ConstantScoreQuery(bq.build()); final Weight weight = searcher.rewrite(q).createWeight(searcher, needsScores, score()); return new WeightOrDocIdSet(weight); } else {
static TopDocs getTopDocs(IndexSearcher searcher, Iterable<? extends String> terms, String targetField) throws IOException { Map<String, RealVector> results = new LinkedHashMap<>(); BooleanQuery.Builder builder = new BooleanQuery.Builder(); for (String term : terms) { builder.add(new TermQuery(new Term(targetField, term)), BooleanClause.Occur.SHOULD); } Query query = builder.build(); TotalHitCountCollector count = new TotalHitCountCollector(); searcher.search(query, count); if (count.getTotalHits() > 0) { return searcher.search(query, count.getTotalHits()); } return null; } }
@Override public long countIndexedNodes( long nodeId, int[] propertyKeyIds, Value... propertyValues ) { Query nodeIdQuery = new TermQuery( LuceneDocumentStructure.newTermForChangeOrRemove( nodeId ) ); Query valueQuery = LuceneDocumentStructure.newSeekQuery( propertyValues ); BooleanQuery.Builder nodeIdAndValueQuery = new BooleanQuery.Builder().setDisableCoord( true ); nodeIdAndValueQuery.add( nodeIdQuery, BooleanClause.Occur.MUST ); nodeIdAndValueQuery.add( valueQuery, BooleanClause.Occur.MUST ); try { TotalHitCountCollector collector = new TotalHitCountCollector(); getIndexSearcher().search( nodeIdAndValueQuery.build(), collector ); // A <label,propertyKeyId,nodeId> tuple should only match at most a single propertyValue return collector.getTotalHits(); } catch ( IOException e ) { throw new RuntimeException( e ); } }
protected int countCollatedMatches(final SuggestWord[] suggestion, final IndexSearcher searcher) { org.apache.lucene.search.BooleanQuery.Builder builder = new org.apache.lucene.search.BooleanQuery.Builder(); for (final SuggestWord word : suggestion) { builder.add(new org.apache.lucene.search.BooleanClause( new TermQuery(new org.apache.lucene.index.Term(dictionaryField, word.string)), org.apache.lucene.search.BooleanClause.Occur.FILTER)); } try { return searcher.count(builder.build()); } catch (final IOException e) { throw new RuntimeException(e); } }
searcher = new IndexSearcher(reader); BooleanQuery query = new BooleanQuery.Builder() .add(parser.parse(qry), BooleanClause.Occur.MUST) .add(filter, BooleanClause.Occur.FILTER) .build(); docs = searcher.search(query, Integer.MAX_VALUE);
/** * Creates complex boolean query from the cached tokenstream contents */ protected Query analyzeMultiBoolean(String field, TokenStream stream, BooleanClause.Occur operator) throws IOException { BooleanQuery.Builder q = newBooleanQuery(); List<Term> currentQuery = new ArrayList<>(); TermToBytesRefAttribute termAtt = stream.getAttribute(TermToBytesRefAttribute.class); PositionIncrementAttribute posIncrAtt = stream.getAttribute(PositionIncrementAttribute.class); stream.reset(); while (stream.incrementToken()) { if (posIncrAtt.getPositionIncrement() != 0) { add(q, currentQuery, operator); currentQuery.clear(); } currentQuery.add(new Term(field, termAtt.getBytesRef())); } add(q, currentQuery, operator); return q.build(); }
final IndexSearcher searcher, Consumer<Runnable> checkCancellationSetter) throws QueryPhaseExecutionException { final IndexReader reader = searcher.getIndexReader(); QuerySearchResult queryResult = searchContext.queryResult(); queryResult.searchTimedOut(false); queryResult.size(searchContext.size()); Query query = searchContext.query(); assert query == searcher.rewrite(query); // already rewritten BooleanQuery bq = new BooleanQuery.Builder() .add(query, BooleanClause.Occur.MUST) .add(new MinDocQuery(after.doc + 1), BooleanClause.Occur.FILTER) .build(); query = bq; BooleanQuery bq = new BooleanQuery.Builder() .add(query, BooleanClause.Occur.MUST) .add(new SearchAfterSortedDocQuery(searchContext.sort().sort, (FieldDoc) after), BooleanClause.Occur.FILTER) .build(); query = bq; searcher.search(query, queryCollector); } catch (EarlyTerminatingCollector.EarlyTerminationException e) { queryResult.terminatedEarly(true);
return new PrefixQuery(new Term(field, termStr)); return new PrefixQuery(new Term(field, tlist.get(0).get(0))); BooleanQuery.Builder builder = new BooleanQuery.Builder(); for (int pos = 0; pos < tlist.size(); pos++) { List<BytesRef> plist = tlist.get(pos); BooleanQuery.Builder innerBuilder = new BooleanQuery.Builder(); for (BytesRef token : plist) { innerBuilder.add(new BooleanClause(new PrefixQuery(new Term(field, token)), BooleanClause.Occur.SHOULD)); posQuery = innerBuilder.build(); builder.add(new BooleanClause(posQuery, getDefaultOperator())); return builder.build();
@Override public Weight createWeight(IndexSearcher searcher, boolean needsScores, float boost) throws IOException { if (needsScores) { return new SynonymWeight(this, searcher, boost); } else { // if scores are not needed, let BooleanWeight deal with optimizing that case. BooleanQuery.Builder bq = new BooleanQuery.Builder(); for (Term term : terms) { bq.add(new TermQuery(term), BooleanClause.Occur.SHOULD); } return searcher.rewrite(bq.build()).createWeight(searcher, needsScores, boost); } }
@Override protected Query topLevelQuery(Term[] terms, TermContext[] ctx, int[] docFreqs, int maxDoc) { BooleanQuery.Builder highBuilder = new BooleanQuery.Builder(); BooleanQuery.Builder lowBuilder = new BooleanQuery.Builder(); for (int i = 0; i < terms.length; i++) { Query query = new TermQuery(terms[i], ctx[i]); if (boosts != null && boosts[i] != 1f) { query = new BoostQuery(query, boosts[i]); highBuilder.add(query, BooleanClause.Occur.SHOULD); } else { lowBuilder.add(query, BooleanClause.Occur.SHOULD); BooleanQuery high = highBuilder.build(); BooleanQuery low = lowBuilder.build(); if (low.clauses().isEmpty()) { BooleanQuery.Builder queryBuilder = new BooleanQuery.Builder(); for (BooleanClause booleanClause : high) { queryBuilder.add(booleanClause.getQuery(), Occur.MUST); return queryBuilder.build(); } else if (high.clauses().isEmpty()) { return low; } else { return new BooleanQuery.Builder() .add(high, BooleanClause.Occur.SHOULD) .add(low, BooleanClause.Occur.MUST) .build();