Refine search
@Override Query encodeQuery( Value value, int propertyNumber ) { return new ConstantScoreQuery( new TermQuery( new Term( key( propertyNumber ), value.asObject().toString() ) ) ); } };
@Test void shouldBuildQueryRepresentingBoolProperty() { // given BooleanQuery booleanQuery = (BooleanQuery) newSeekQuery( true ); ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 0 ).getQuery(); TermQuery query = (TermQuery) constantScoreQuery.getQuery(); // then assertEquals( "true", query.getTerm().text() ); }
@Override public int hashCode() { return 31 * classHash() + query.hashCode(); } }
@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); }
BooleanQuery builder = new BooleanQuery(); BooleanQuery childBuilder = new BooleanQuery(); int rowInBand = 0; for (BytesRef minHash : minhashes) { TermQuery tq = new TermQuery(new Term(field, minHash)); if (bandSize == 1) { builder.add(new ConstantScoreQuery(tq), BooleanClause.Occur.SHOULD); } else { childBuilder.add(new ConstantScoreQuery(tq), BooleanClause.Occur.MUST); rowInBand++; if (rowInBand == bandSize) { builder.add(new ConstantScoreQuery(childBuilder), BooleanClause.Occur.SHOULD); childBuilder = new BooleanQuery(); if (childBuilder.clauses().size() > 0) { for (BytesRef token : minhashes) { TermQuery tq = new TermQuery(new Term(field, token.toString())); childBuilder.add(new ConstantScoreQuery(tq), BooleanClause.Occur.MUST); rowInBand++; if (rowInBand == bandSize) { builder.add(new ConstantScoreQuery(childBuilder), BooleanClause.Occur.SHOULD); break;
return mightMatchNonNestedDocs(((ConstantScoreQuery) query).getQuery(), nestedPath); } else if (query instanceof BoostQuery) { return mightMatchNonNestedDocs(((BoostQuery) query).getQuery(), nestedPath); return false; } else if (query instanceof TermQuery) { return mightMatchNonNestedDocs(((TermQuery) query).getTerm().field(), nestedPath); } else if (query instanceof TermInSetQuery) { PrefixCodedTerms terms = ((TermInSetQuery) query).getTermData(); } else if (query instanceof BooleanQuery) { final BooleanQuery bq = (BooleanQuery) query; final boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired); if (hasRequiredClauses) { return bq.clauses().stream() .filter(BooleanClause::isRequired) .map(BooleanClause::getQuery) .allMatch(q -> mightMatchNonNestedDocs(q, nestedPath)); } else { return bq.clauses().stream() .filter(c -> c.getOccur() == Occur.SHOULD) .map(BooleanClause::getQuery) .anyMatch(q -> mightMatchNonNestedDocs(q, nestedPath));
while (true) { if (subQuery instanceof ConstantScoreQuery) { subQuery = ((ConstantScoreQuery) subQuery).getQuery(); boost = 1; } else if (subQuery instanceof BoostQuery) { PrefixQuery prefixQuery = new PrefixQuery(new Term(fieldName, prefixBuilder.value())); if (prefixBuilder.rewrite() != null) { MultiTermQuery.RewriteMethod rewriteMethod = SpanTermQuery spanTermQuery = new SpanTermQuery(((TermQuery) subQuery).getTerm()); spanQuery = new FieldMaskingSpanQuery(spanTermQuery, fieldName);
private Query newTermQuery(IndexReader reader, Term term) throws IOException { if (ignoreTF) { return new ConstantScoreQuery(new TermQuery(term)); } else { // we build an artificial TermContext that will give an overall df and ttf // equal to 1 TermContext context = new TermContext(reader.getContext()); for (LeafReaderContext leafContext : reader.leaves()) { Terms terms = leafContext.reader().terms(term.field()); if (terms != null) { TermsEnum termsEnum = terms.iterator(); if (termsEnum.seekExact(term.bytes())) { int freq = 1 - context.docFreq(); // we want the total df and ttf to be 1 context.register(termsEnum.termState(), leafContext.ord, freq, freq); } } } return new TermQuery(term, context); } }
@Override protected void addClause(BooleanQuery.Builder topLevel, Term term, int docFreq, float boost, TermContext states) { final Query q = new ConstantScoreQuery(new TermQuery(term, states)); topLevel.add(new BoostQuery(q, boost), BooleanClause.Occur.SHOULD); } }
return new BooleanQuery(true); final Query tq = new ConstantScoreQuery(new TermQuery(term)); tq.setBoost(boost); topLevel.add(tq, BooleanClause.Occur.SHOULD); Iterator<BooleanClause> iterator = bq.iterator(); while(iterator.hasNext()) next.getQuery().setBoost(next.getQuery().getBoost() * idfBoost);
flatten(sourceQuery, reader, flatQueries, boost); } else if (sourceQuery instanceof SpanTermQuery) { super.flatten(new TermQuery(((SpanTermQuery) sourceQuery).getTerm()), reader, flatQueries, boost); } else if (sourceQuery instanceof ConstantScoreQuery) { flatten(((ConstantScoreQuery) sourceQuery).getQuery(), reader, flatQueries, boost); } else if (sourceQuery instanceof FunctionScoreQuery) { flatten(((FunctionScoreQuery) sourceQuery).getSubQuery(), reader, flatQueries, boost); flatten(new TermQuery(term), reader, flatQueries, boost);
BooleanQuery bq = (BooleanQuery)sourceQuery; for( BooleanClause clause : bq ) { if( !clause.isProhibited() ) { flatten( clause.getQuery(), reader, flatQueries, boost ); PhraseQuery pq = (PhraseQuery)sourceQuery; if( pq.getTerms().length == 1 ) sourceQuery = new TermQuery( pq.getTerms()[0] ); if (boost != 1f) { sourceQuery = new BoostQuery(sourceQuery, boost); final Query q = ((ConstantScoreQuery) sourceQuery).getQuery(); if (q != null) { flatten( q, reader, flatQueries, boost);
Query query = c.getQuery(); if (minimumNumberShouldMatch == 1 && c.getOccur() == Occur.SHOULD) { return query; } else if (minimumNumberShouldMatch == 0) { switch (c.getOccur()) { case SHOULD: case MUST: case FILTER: return new BoostQuery(new ConstantScoreQuery(query), 0); case MUST_NOT: builder.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch()); boolean actuallyRewritten = false; for (BooleanClause clause : this) { if (modified) { BooleanQuery.Builder builder = new BooleanQuery.Builder(); builder.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch()); for (BooleanClause clause : clauses) { if (clause.getOccur() != Occur.FILTER) { int minShouldMatch = getMinimumNumberShouldMatch(); rewritten = new ConstantScoreQuery(rewritten); if (boost != 1f) { rewritten = new BoostQuery(rewritten, boost);
@SuppressWarnings( "unchecked" ) @Test void shouldBuildQueryRepresentingNumberProperty() { // given BooleanQuery booleanQuery = (BooleanQuery) newSeekQuery( 12 ); ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 0 ).getQuery(); NumericRangeQuery<Double> query = (NumericRangeQuery<Double>) constantScoreQuery.getQuery(); // then assertEquals( 12.0, query.getMin(), 0.001 ); assertEquals( 12.0, query.getMax(),0.001 ); }
if (query instanceof BooleanQuery) { for (BooleanClause clause : (BooleanQuery) query) { if (!clause.isProhibited()) { list.addAll(Arrays.asList(extractAutomata(clause.getQuery(), field))); list.addAll(Arrays.asList(extractAutomata(((FilteredQuery) query).getQuery(), field))); } else if (query instanceof ConstantScoreQuery) { list.addAll(Arrays.asList(extractAutomata(((ConstantScoreQuery) query).getQuery(), field))); } else if (query instanceof DisjunctionMaxQuery) { for (Query sub : ((DisjunctionMaxQuery) query).getDisjuncts()) { final PrefixQuery pq = (PrefixQuery) query; Term prefix = pq.getPrefix(); if (prefix.field().equals(field)) { list.add(new CharacterRunAutomaton(Operations.concatenate(Automata.makeString(prefix.text()), Automata.makeAnyString())) { @Override final FuzzyQuery fq = (FuzzyQuery) query; if (fq.getField().equals(field)) { String utf16 = fq.getTerm().text(); int termText[] = new int[utf16.codePointCount(0, utf16.length())]; for (int cp, i = 0, j = 0; i < utf16.length(); i += Character.charCount(cp)) {
@Override public Query rewrite(IndexReader reader) throws IOException { if (getBoost() != 1f) { return super.rewrite(reader); Query query = c.getQuery(); if (minimumNumberShouldMatch == 1 && c.getOccur() == Occur.SHOULD) { return query; } else if (minimumNumberShouldMatch == 0) { switch (c.getOccur()) { case SHOULD: case MUST: case FILTER: return new BoostQuery(new ConstantScoreQuery(query), 0); case MUST_NOT: builder.setDisableCoord(isCoordDisabled()); builder.setMinimumNumberShouldMatch(getMinimumNumberShouldMatch()); boolean actuallyRewritten = false; for (BooleanClause clause : this) { rewritten = new ConstantScoreQuery(rewritten); if (boost != 1f) { rewritten = new BoostQuery(rewritten, boost);
/** * Creates a lucene query that will restrict result to issues which are satisfy query executed on other index. * * @param indexQuery the lucene query that will be executed on passed index * @param indexName the name of the index used in searching. The index name should be provided by {@link com.atlassian.jira.issue.search.SearchProviderFactory} * Documents on this index should have the field which represents issue id. * * @return the constant score lucene query which will filters by issue ids. Return empty BooleanQuery when exception was caught. */ public Query createIssueIdFilterQuery(final Query indexQuery, final String indexName) { try { if (log.isDebugEnabled()) { log.debug("Searching the " + indexName + " index using the query: " + indexQuery.toString()); } // Now we need to execute the search and build up a new query that enumerates the issue id's found by the index search final IndexSearcher searcher = searchProviderFactory.getSearcher(indexName); final IssueIdCollector collector = new IssueIdCollector(searcher.getIndexReader()); searcher.search(indexQuery, collector); final Set<String> issueIds = collector.getIssueIds(); return new ConstantScoreQuery(new IssueIdFilter(issueIds)); } catch (final IOException e) { log.error("Unable to search the " + indexName + " index.", e); return new BooleanQuery(); } }
q.add(new BooleanClause(left, BooleanClause.Occur.SHOULD)); q.add(new BooleanClause(right, BooleanClause.Occur.SHOULD)); return new ConstantScoreQuery(q.build()); } else { return newBoxInternal(field, lower, upper);
@Override public Query rewrite(IndexReader reader, MultiTermQuery query) throws IOException { final Query bq = SCORING_BOOLEAN_REWRITE.rewrite(reader, query); // strip the scores off return new ConstantScoreQuery(bq); } };
} else if (query instanceof BooleanQuery) { for (BooleanClause clause : (BooleanQuery) query) { if (!clause.isProhibited()) { extract(clause.getQuery(), boost, terms); extract(((FilteredQuery) query).getQuery(), boost, terms); } else if (query instanceof ConstantScoreQuery) { final Query q = ((ConstantScoreQuery) query).getQuery(); if (q != null) { extract(q, boost, terms);