@Override public void extractTerms(Set<Term> terms) { terms.add(getTerm()); }
private void getTerm(TermQuery query) { highlight.add(query.getTerm().text()); }
private void getTerm(TermQuery query) { Term term = query.getTerm(); if (useTerm(term)) { String text = term.text(); if (isCaseInsensitive(term)) { caseInsensitiveTerms.add(text); } else { caseSensitiveTerms.add(text); } } }
/** * Decomposes the provided {@code query} into terms with the exception of {@link PhraseQuery}. Is useful when * determining which terms should not be suggested. {@link PhraseQuery} is exempted because not suggesting some * term which were contained in it is invalid. * @param query query to decompose * @return terms that were in the {@code query} */ public static List<Term> intoTermsExceptPhraseQuery(final Query query) { if (query == null) { return Collections.emptyList(); } List<Term> terms = new LinkedList<>(); LinkedList<Query> queue = new LinkedList<>(); queue.add(query); while (!queue.isEmpty()) { Query q = queue.poll(); if (q instanceof BooleanQuery) { for (BooleanClause bc : ((BooleanQuery) q).clauses()) { queue.add(bc.getQuery()); } } else if (q instanceof TermQuery) { terms.add(((TermQuery) q).getTerm()); } } return terms; }
/** * Decomposes the provided {@code query} into terms. * @param query query to decompose * @return terms that were in the {@code query} */ public static List<Term> intoTerms(final Query query) { if (query == null) { return Collections.emptyList(); } List<Term> terms = new LinkedList<>(); LinkedList<Query> queue = new LinkedList<>(); queue.add(query); while (!queue.isEmpty()) { Query q = queue.poll(); if (q instanceof BooleanQuery) { for (BooleanClause bc : ((BooleanQuery) q).clauses()) { queue.add(bc.getQuery()); } } else if (q instanceof TermQuery) { terms.add(((TermQuery) q).getTerm()); } else if (q instanceof PhraseQuery) { terms.addAll(Arrays.asList(((PhraseQuery) q).getTerms())); } } return terms; }
byte[] rawTags = doc.getField(QueryBuilder.TAGS).binaryValue().bytes; Definitions tags = Definitions.deserialize(rawTags); String symbol = ((TermQuery) query).getTerm().text(); if (tags.occurrences(symbol) == 1) { uniqueDefinition = true; redirect = contextPath + Prefix.XREF_P + Util.URIEncodePath(searcher.doc(hits[0].doc).get(QueryBuilder.PATH)) + '#' + Util.URIEncode(((TermQuery) query).getTerm().text());
private String extractTermField( Query query ) { // Try common types of queries if ( query instanceof TermQuery ) { return ((TermQuery)query).getTerm().field(); } else if ( query instanceof WildcardQuery ) { return ((WildcardQuery)query).getTerm().field(); } else if ( query instanceof PrefixQuery ) { return ((PrefixQuery)query).getPrefix().field(); } else if ( query instanceof MatchAllDocsQuery ) { return null; } // Try to extract terms and get it that way String field = getFieldFromExtractTerms( query ); if ( field != null ) { return field; } // Last resort: since Query doesn't have a common interface for getting // the term/field of its query this is one option. return getFieldViaReflection( query ); }
@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() ); }
@Test void shouldBuildQueryRepresentingStringProperty() { // given BooleanQuery booleanQuery = (BooleanQuery) newSeekQuery( "Characters" ); ConstantScoreQuery query = (ConstantScoreQuery) booleanQuery.clauses().get( 0 ).getQuery(); // then assertEquals( "Characters", ((TermQuery) query.getQuery()).getTerm().text() ); }
@Test void shouldBuildQueryRepresentingArrayProperty() { // given BooleanQuery booleanQuery = (BooleanQuery) newSeekQuery( new Object[]{new Integer[]{1, 2, 3}} ); ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 0 ).getQuery(); TermQuery query = (TermQuery) constantScoreQuery.getQuery(); // then assertEquals( "D1.0|2.0|3.0|", query.getTerm().text() ); }
return reader.numDocs(); } else if (query instanceof TermQuery && reader.hasDeletions() == false) { Term term = ((TermQuery) query).getTerm(); int count = 0; for (LeafReaderContext leaf : reader.leaves()) {
@Test void shouldBuildQueryRepresentingMultipleProperties() { // given BooleanQuery booleanQuery = (BooleanQuery) newSeekQuery( true, "Characters", 12, new Integer[]{1, 2, 3} ); ConstantScoreQuery boolScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 0 ).getQuery(); TermQuery boolTermQuery = (TermQuery) boolScoreQuery.getQuery(); ConstantScoreQuery stringScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 1 ).getQuery(); TermQuery stringTermQuery = (TermQuery) stringScoreQuery.getQuery(); ConstantScoreQuery numberScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 2 ).getQuery(); NumericRangeQuery<Double> numericRangeQuery = (NumericRangeQuery<Double>) numberScoreQuery.getQuery(); ConstantScoreQuery arrayScoreQuery = (ConstantScoreQuery) booleanQuery.clauses().get( 3 ).getQuery(); TermQuery arrayTermQuery = (TermQuery) arrayScoreQuery.getQuery(); // then assertEquals( "true", boolTermQuery.getTerm().text() ); assertEquals( "Characters", stringTermQuery.getTerm().text() ); assertEquals( 12.0, numericRangeQuery.getMin(), 0.001 ); assertEquals( 12.0, numericRangeQuery.getMax(), 0.001 ); assertEquals( "D1.0|2.0|3.0|", arrayTermQuery.getTerm().text() ); }
private static void planTermQuery(final StringBuilder builder, final TermQuery query) { builder.append(query.getTerm()); }
private Query boolToExtendedCommonTermsQuery(BooleanQuery bq, Occur highFreqOccur, Occur lowFreqOccur, float maxTermFrequency, MappedFieldType fieldType) { ExtendedCommonTermsQuery query = new ExtendedCommonTermsQuery(highFreqOccur, lowFreqOccur, maxTermFrequency, fieldType); for (BooleanClause clause : bq.clauses()) { if (!(clause.getQuery() instanceof TermQuery)) { return bq; } query.add(((TermQuery) clause.getQuery()).getTerm()); } return query; } }
+ termQuery.getClass() + ": " + termQuery); return ((TermQuery) termQuery).getTerm();
return reader.numDocs(); } else if (query.getClass() == TermQuery.class && reader.hasDeletions() == false) { final Term term = ((TermQuery) query).getTerm(); int count = 0; for (LeafReaderContext context : reader.leaves()) {
private QueryNode internalParse(org.apache.lucene.search.Query luceneQuery, final String originalStr) throws ParseException { QueryNode node; if (luceneQuery instanceof org.apache.lucene.search.TermQuery) { Term t = ((org.apache.lucene.search.TermQuery) luceneQuery).getTerm(); String field = t.field(); String text = t.text(); node = new TermQuery(field, text); } else if (luceneQuery instanceof org.apache.lucene.search.PrefixQuery) { Term t = ((org.apache.lucene.search.PrefixQuery) luceneQuery).getPrefix(); String field = t.field(); String text = t.text(); node = new PrefixTermQuery(field, text); } else if (luceneQuery instanceof org.apache.lucene.search.BooleanQuery) { List<BooleanClause> clauses = ((org.apache.lucene.search.BooleanQuery) luceneQuery).clauses(); if (clauses.isEmpty()) { throw new ParseException("error parsing: " + originalStr); } node = internalParseBooleanQuery(clauses, originalStr); } else if (luceneQuery instanceof org.apache.lucene.search.PhraseQuery) { org.apache.lucene.search.PhraseQuery phraseQuery = (org.apache.lucene.search.PhraseQuery) luceneQuery; int[] positions = phraseQuery.getPositions(); node = internalParsePhraseQuery(phraseQuery.getTerms(), positions, originalStr); } else { throw new ParseException("unimplemented"); } node.setBoost(luceneQuery.getBoost()); return node; }
private long getBackgroundFrequency(String value) throws IOException { Query query = fieldType.termQuery(value, context.getQueryShardContext()); if (query instanceof TermQuery) { // for types that use the inverted index, we prefer using a caching terms // enum that will do a better job at reusing index inputs Term term = ((TermQuery) query).getTerm(); FilterableTermsEnum termsEnum = getTermsEnum(term.field()); if (termsEnum.seekExact(term.bytes())) { return termsEnum.docFreq(); } else { return 0; } } // otherwise do it the naive way if (filter != null) { query = new BooleanQuery.Builder() .add(query, Occur.FILTER) .add(filter, Occur.FILTER) .build(); } return context.searcher().count(query); }
private long getBackgroundFrequency(String value) throws IOException { Query query = fieldType.termQuery(value, context.getQueryShardContext()); if (query instanceof TermQuery) { // for types that use the inverted index, we prefer using a caching terms // enum that will do a better job at reusing index inputs Term term = ((TermQuery) query).getTerm(); FilterableTermsEnum termsEnum = getTermsEnum(term.field()); if (termsEnum.seekExact(term.bytes())) { return termsEnum.docFreq(); } else { return 0; } } // otherwise do it the naive way if (filter != null) { query = new BooleanQuery.Builder() .add(query, Occur.FILTER) .add(filter, Occur.FILTER) .build(); } return context.searcher().count(query); }
prefixQuery.add(((TermQuery) innerQuery).getTerm()); return boost == 1 ? prefixQuery : new BoostQuery(prefixQuery, boost); } else if (innerQuery instanceof AllTermQuery) {