Refine search
protected Query like(Operation<?> operation, QueryMetadata metadata) { verifyArguments(operation); Path<?> path = getPath(operation.getArg(0)); String field = toField(path); String[] terms = convert(path, operation.getArg(1)); if (terms.length > 1) { BooleanQuery bq = new BooleanQuery(); for (String s : terms) { bq.add(new WildcardQuery(new Term(field, "*" + s + "*")), Occur.MUST); } return bq; } return new WildcardQuery(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 ); }
private Query buildQuery(final Map<String, ?> attrs, final ClusterSegment... clusterSegments) { final BooleanQuery.Builder query = new BooleanQuery.Builder(); for (final Map.Entry<String, ?> entry : attrs.entrySet()) { if (entry.getValue() instanceof DateRange) { final Long from = ((DateRange) entry.getValue()).after().getTime(); final Long to = ((DateRange) entry.getValue()).before().getTime(); query.add(LegacyNumericRangeQuery.newLongRange(entry.getKey(), from, to, true, true), MUST); } else if (entry.getValue() instanceof String) { query.add(new WildcardQuery(new Term(entry.getKey(), entry.getValue().toString())), MUST); } else if (entry.getValue() instanceof Boolean) { query.add(new TermQuery(new Term(entry.getKey(), ((Boolean) entry.getValue()) ? "0" : "1")), MUST); } } return composeQuery(query.build(), clusterSegments); }
public static Query newWildCardStringQuery( String searchFor ) { String searchTerm = QueryParser.escape( searchFor ); Term term = new Term( ValueEncoding.String.key( 0 ), "*" + searchTerm + "*" ); return new WildcardQuery( term ); }
@Override public Query visit(TermQuery termQuery, Field field) { if( field != Field.NAME ) return termQuery; Term term = termQuery.getTerm(); String text = term.text(); if( text.matches("[A-Z][a-z0-9_]*[A-Z].*") ) { // if has several uppercase letters BooleanQuery bq = new BooleanQuery(); bq.add(termQuery, Occur.SHOULD); String wcText = text.replaceAll("([A-Z][a-z0-9_]*)", "$1*"); Term wcTerm = Field.NAME.createTerm(wcText); WildcardQuery wcQuery = new WildcardQuery(wcTerm); wcQuery.setBoost( termQuery.getBoost()/2f ); bq.add(wcQuery, Occur.SHOULD); return bq; } return super.visit(termQuery, field); } }
@Override protected void applyConstraints(BooleanQuery.Builder builder) { if (fileNames != null) { BooleanQuery.Builder subQueryBuilder = new BooleanQuery.Builder(); for (String pattern: Splitter.on(",").omitEmptyStrings().trimResults().split(fileNames.toLowerCase())) subQueryBuilder.add(new WildcardQuery(new Term(BLOB_NAME.name(), pattern)), Occur.SHOULD); BooleanQuery subQuery = subQueryBuilder.build(); if (subQuery.clauses().size() != 0) builder.add(subQuery, Occur.MUST); } if (regex) builder.add(new RegexLiterals(term).asNGramQuery(BLOB_TEXT.name(), NGRAM_SIZE), Occur.MUST); else if (term.length() >= NGRAM_SIZE) builder.add(new NGramLuceneQuery(BLOB_TEXT.name(), term, NGRAM_SIZE), Occur.MUST); else throw new TooGeneralQueryException(); }
@Override public Automaton getAutomaton(Options options) { Term term = new Term(field, value); return WildcardQuery.toAutomaton(term); }
Set<String> fieldSet = Sets.newHashSet(); fieldSet.add(rangeQueryField); BooleanQuery fieldsQuery = new BooleanQuery(); for (String field : fields) { fieldSet.add(field); WildcardQuery queryPart = new WildcardQuery(new Term(field, queryText)); fieldsQuery.add(queryPart, Occur.SHOULD); } BooleanQuery query = new BooleanQuery(); query.add(fieldsQuery, Occur.MUST); NumericRangeFilter<Long> longNumericRangeFilter = NumericRangeFilter.newLongRange(rangeQueryField, rangeValue, Long.MAX_VALUE, false, false); MultiFieldQueryParser queryParser = new MultiFieldQueryParser(version, fieldSet.toArray(new String[0]), analyzer); queryParser.setAllowLeadingWildcard(true); Query q = queryParser.parse(query.toString()); TopFieldDocs searchResults = searcher.search(q, longNumericRangeFilter, maxResultsToReturn, sort);
@Override public Query visit(WildcardQuery wildcardQuery, Field termField) { Term t = wildcardQuery.getTerm(); if( termField == null && aliases.containsKey(t.field()) ) { Field field = aliases.get(t.field()); Term newTerm = field.createTerm(t.text()); WildcardQuery newTermQuery = new WildcardQuery(newTerm); return newTermQuery; } return super.visit(wildcardQuery, termField); } }
@Override public Query visit(WildcardQuery wildcardQuery, Field field) { if( field == Field.CONTENTS ) { Term term = wildcardQuery.getTerm(); return new WildcardQuery( field.createTerm( term.text().toLowerCase(Locale.ENGLISH) ) ); } return super.visit(wildcardQuery, field); }
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(TermQuery termQuery, Field field) { Term t = termQuery.getTerm(); if( field == Field.DIR ) { if( t.text().startsWith("/") ) // already absolute { Term fileTerm = Field.FILE.createTerm(t.text()); return new PrefixQuery(fileTerm); } Term fileTerm = Field.FILE.createTerm("/*/" + t.text() + "/*"); return new WildcardQuery(fileTerm); } return super.visit(termQuery, field); }
private static JsonObject convertWildcardQuery(WildcardQuery query) { String field = query.getTerm().field(); JsonObject wildcardQuery = JsonBuilder.object() .add( "wildcard", JsonBuilder.object().add( field, JsonBuilder.object() .addProperty( "value", query.getTerm().text() ) .addProperty( "boost", query.getBoost() ) ) ).build(); return wrapQueryForNestedIfRequired( field, wildcardQuery ); }
public Set<String> extractTerms(Query query) { Set<String> terms = new HashSet<String>(); if (query instanceof BooleanQuery) { BooleanQuery b = (BooleanQuery) query; for (BooleanClause bc : b.getClauses()) { Query q = bc.getQuery(); terms.addAll(extractTerms(q)); } } else if (query instanceof TermQuery) { TermQuery tq = (TermQuery) query; terms.add(tq.getTerm().text()); } else if (query instanceof WildcardQuery) { WildcardQuery wq = (WildcardQuery) query; terms.add(wq.getTerm().text()); } return terms; }
/** Prints a user-readable version of this query. */ @Override public String toString(String field) { StringBuilder buffer = new StringBuilder(); if (!getField().equals(field)) { buffer.append(getField()); buffer.append(":"); } buffer.append(term.text()); buffer.append(ToStringUtils.boost(getBoost())); return buffer.toString(); } }
@Override public Query wildcardQuery(String value, MultiTermQuery.RewriteMethod method, QueryShardContext context) { Query termQuery = termQuery(value, context); if (termQuery instanceof MatchNoDocsQuery || termQuery instanceof MatchAllDocsQuery) { return termQuery; } Term term = MappedFieldType.extractTerm(termQuery); WildcardQuery query = new WildcardQuery(term); QueryParsers.setRewriteMethod(query, method); return query; }