Refine search
protected Query startsWith(QueryMetadata metadata, Operation<?> operation, boolean ignoreCase) { verifyArguments(operation); Path<?> path = getPath(operation.getArg(0)); String field = toField(path); String[] terms = convertEscaped(path, operation.getArg(1), metadata); if (terms.length > 1) { BooleanQuery bq = new BooleanQuery(); for (int i = 0; i < terms.length; ++i) { String s = i == 0 ? terms[i] + "*" : "*" + terms[i] + "*"; bq.add(new WildcardQuery(new Term(field, s)), Occur.MUST); } return bq; } return new PrefixQuery(new Term(field, terms[0])); }
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 ); }
@Override public org.apache.lucene.search.Query getLuceneQuery() { org.apache.lucene.search.PrefixQuery luceneQuery = new org.apache.lucene.search.PrefixQuery(new Term(field, term)); luceneQuery.setBoost(boost); return luceneQuery; }
/** This is called if the last token isn't ended * (e.g. user did not type a space after it). Return an * appropriate Query clause to add to the BooleanQuery. */ protected Query getLastTokenQuery(String token) throws IOException { if (token.length() < minPrefixChars) { // The leading ngram was directly indexed: return new TermQuery(new Term("textgrams", token)); } return new PrefixQuery(new Term(TEXT_FIELD_NAME, token)); }
@Override public Query prefixQuery(String value, MultiTermQuery.RewriteMethod method, QueryShardContext context) { failIfNotIndexed(); PrefixQuery query = new PrefixQuery(new Term(name(), indexedValueForSearch(value))); if (method != null) { query.setRewriteMethod(method); } return query; }
public QueryBuilder pathPrefix(String pathPrefix) { Term term = new Term(FieldNames.PATH, pathPrefix); queries.add(new PrefixQuery(term)); return this; }
PrefixQuery prefixQuery = new PrefixQuery(new Term(fieldName, prefixBuilder.value())); if (prefixBuilder.rewrite() != null) { MultiTermQuery.RewriteMethod rewriteMethod = QueryParsers.parseRewriteMethod(prefixBuilder.rewrite(), null, LoggingDeprecationHandler.INSTANCE); prefixQuery.setRewriteMethod(rewriteMethod); SpanTermQuery spanTermQuery = new SpanTermQuery(((TermQuery) subQuery).getTerm()); spanQuery = new FieldMaskingSpanQuery(spanTermQuery, fieldName);
@Override public Query visit(TermQuery termQuery, Field field) { if( clauseCount == 0 ) { // at last query Term term = termQuery.getTerm(); if( term.text().length() < minTermLength ) // exclude short queries to avoid clause overload return termQuery; PrefixQuery prefixQuery = new PrefixQuery(term); prefixQuery.setBoost( termQuery.getBoost()/4f ); BooleanQuery boolQuery = new BooleanQuery(); boolQuery.add(termQuery, Occur.SHOULD); boolQuery.add(prefixQuery, Occur.SHOULD); boolQuery.setBoost( termQuery.getBoost() ); return boolQuery; } return termQuery; }
return new PrefixQuery(new Term(defaultField.getIndexKey(), patternString)); q = qp.parse(patternString); } catch (ParseException e) { return new PrefixQuery(new Term(defaultField.getIndexKey(), patternString)); for (BooleanClause clause : query.getClauses()) { if (clause.getQuery() instanceof TermQuery) { TermQuery termQuery = (TermQuery) clause.getQuery(); clause.setQuery(new PrefixQuery(termQuery.getTerm())); return new PrefixQuery(((TermQuery) q).getTerm());
/** * Loads all the prefix terms in the list of terms given the reader. * * @param reader Index reader to use. * @param values The list of values to load. * @param term The term to use. * * @throws IOException If an error is thrown by the prefix term enumeration. */ public static void prefix(IndexReader reader, Bucket<Term> bucket, Term term) throws IOException { Fields fields = MultiFields.getFields(reader); org.apache.lucene.index.Terms terms = fields == null ? null : fields.terms(term.field()); if (terms == null) return; TermsEnum prefixes = terms.intersect(new CompiledAutomaton(PrefixQuery.toAutomaton(term.bytes())), term.bytes()); BytesRef val; while ((val = prefixes.next()) != null) { Term t = new Term(term.field(), BytesRef.deepCopyOf(val)); bucket.add(t, reader.docFreq(t)); } }
Term t = q.getTerm(); FieldType ft = writeFieldName(t.field(), schema, out, flags); writeFieldVal(t.text(), ft, out, flags); } else if (query instanceof TermRangeQuery) { TermRangeQuery q = (TermRangeQuery)query; boolean needParens=false; if (q.getBoost() != 1.0 || q.getMinimumNumberShouldMatch() != 0) { needParens=true; for (BooleanClause c : (List<BooleanClause>)q.clauses()) { if (!first) { out.append(' '); Term prefix = q.getPrefix(); FieldType ft = writeFieldName(prefix.field(), schema, out, flags); out.append(prefix.text()); out.append('*');
BooleanQuery booleanQuery = new BooleanQuery(); for(String token : tokens) { booleanQuery.add(new PrefixQuery(new Term(fieldName, token)), Occur.MUST); }
for (int j = 0; j < terms[i].length; j++) { if (i == sizeMinus1) { innerQueries[j] = new SpanMultiTermQueryWrapper(new PrefixQuery(terms[i][j])); } else { innerQueries[j] = new SpanTermQuery(terms[i][j]); List<Query> tqs = new ArrayList<> (); for (Term term : ctq.getTerms()) { tqs.add(new TermQuery(term)); return Collections.singletonList(new TermQuery(atq.getTerm())); } else if (query instanceof FunctionScoreQuery) { return Collections.singletonList(((FunctionScoreQuery) query).getSubQuery());
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; }
BooleanClause[] c = ((BooleanQuery)q).getClauses(); if (c.length==1) { Query q1 = c[0].getQuery(); if (q1 instanceof PrefixQuery && "u".equals(((PrefixQuery)q1).getPrefix().field())) { } else if (q1 instanceof TermQuery && "p".equals(((TermQuery) q1).getTerm().field())) { int oldMax = BooleanQuery.getMaxClauseCount(); try { int max = oldMax; IteratorSearchResponse response; try { BooleanQuery.setMaxClauseCount(max); response = searcher.searchIteratorPaged(isr, contexts); LOGGER.log(Level.FINE, "passed on {0} clauses processing {1} with {2} hits", new Object[] {max, q, response.getTotalHitsCount()});
return new BooleanQuery(true); final Query tq = new ConstantScoreQuery(new TermQuery(term)); tq.setBoost(boost); topLevel.add(tq, BooleanClause.Occur.SHOULD); df = reader.docFreq(fq.getPrefix()); if(df>=1) Iterator<BooleanClause> iterator = bq.iterator(); while(iterator.hasNext())
@Override public Query visit(PrefixQuery prefixQuery, Field termField) { Term t = prefixQuery.getPrefix(); if( termField == null && aliases.containsKey(t.field()) ) { Field field = aliases.get(t.field()); Term newTerm = field.createTerm(t.text()); PrefixQuery newTermQuery = new PrefixQuery(newTerm); return newTermQuery; } return super.visit(prefixQuery, termField); }
Field field = Field.getByName(termQuery.getTerm().field()); BooleanQuery newBoolQuery = queryVisitor.visit(boolQuery); for(BooleanClause boolClause: boolQuery.getClauses()) { if( ! queryVisitor.visit(boolClause) ) continue; Query newQuery = accept( boolClause.getQuery(), queryVisitor ); newBoolQuery.setBoost( boolQuery.getBoost() ); newBoolQuery.setMinimumNumberShouldMatch(boolQuery.getMinimumNumberShouldMatch()); Field field = Field.getByName(wildcardQuery.getTerm().field()); Field field = Field.getByName(prefixQuery.getPrefix().field());
@Override public Query visit(PrefixQuery prefixQuery, Field field) { if( field == Field.CONTENTS ) { Term term = prefixQuery.getPrefix(); return new PrefixQuery( field.createTerm( term.text().toLowerCase(Locale.ENGLISH) ) ); } return super.visit(prefixQuery, field); }