Query q = QueryParsing.parseQuery(cmd.query, schema); long total = writer.deleteDocuments(subIndex, q, false); commit(subIndex, true);
/** * Builds a list of String which are stringified versions of a list of Queries */ public static List<String> toString(List<Query> queries, IndexSchema schema) { List<String> out = new ArrayList<String>(queries.size()); for (Query q : queries) { out.add(QueryParsing.toString(q, schema)); } return out; }
/** * Executes a basic query in lucene syntax */ public static DocList doSimpleQuery(String sreq, SolrIndexSearcher searcher, IndexSchema schema, int start, int limit) throws IOException { List<String> commands = StrUtils.splitSmart(sreq,';'); String qs = commands.size() >= 1 ? commands.get(0) : ""; Query query = QueryParsing.parseQuery(qs, schema); // If the first non-query, non-filter command is a simple sort on an indexed field, then // we can use the Lucene sort ability. Sort sort = null; if (commands.size() >= 2) { sort = QueryParsing.parseSort(commands.get(1), schema); } DocList results = searcher.getDocList(query,(DocSet)null, sort, start, limit); return results; }
TermQuery q = (TermQuery)query; 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; String fname = q.getField(); FieldType ft = writeFieldName(fname, schema, out, flags); out.append( q.includesLower() ? '[' : '{' ); String lt = q.getLowerTerm(); out.append('*'); } else { writeFieldVal(lt, ft, out, flags); out.append('*'); } else { writeFieldVal(ut, ft, out, flags); NumericRangeQuery q = (NumericRangeQuery)query; String fname = q.getField(); FieldType ft = writeFieldName(fname, schema, out, flags); out.append( q.includesMin() ? '[' : '{' ); Number lt = q.getMin(); toString(subQuery, schema, out, flags); PrefixQuery q = (PrefixQuery)query; Term prefix = q.getPrefix();
int matchOffset = params.getInt( MoreLikeThisParams.MATCH_OFFSET, 0 ); Query query = QueryParsing.parseQuery(q, params.get(CommonParams.DF), params, req.getSchema()); DocList match = searcher.getDocList(query, null, null, matchOffset, 1, flags ); // only get the first one... if( includeMatch ) { List<String> fqs = new ArrayList<String>(filters.size()); for (Query fq : filters) { fqs.add(QueryParsing.toString(fq, req.getSchema()));
private void addTreeFieldsToFacets(ResponseBuilder rb) throws SyntaxError { String[] ftFields = rb.req.getParams().getParams(FACET_TREE_FIELD); if (ftFields == null || ftFields.length == 0) { LOGGER.warn("No facet tree fields specified - ignoring facet trees"); } else { // Take a modifiable copy of the incoming params ModifiableSolrParams params = new ModifiableSolrParams(rb.req.getParams()); // Put the original facet fields (if any) into a Set Set<String> facetFields = new LinkedHashSet<>(); if (params.getParams(FacetParams.FACET_FIELD) != null) { facetFields.addAll(Arrays.asList(params.getParams(FacetParams.FACET_FIELD))); } // Add the facet tree fields for (String ftField : ftFields) { // Parse the facet tree field, so we only add the field value, // rather than the whole string (ensure it's unique) facetFields.add(QueryParsing.getLocalParams(ftField, params).get(QueryParsing.V)); } // Add the (possibly) new facet fields params.set(FacetParams.FACET_FIELD, facetFields.toArray(new String[facetFields.size()])); // Re-set the params in the request rb.req.setParams(params); } }
/** * Uses {@link SolrPluginUtils#parseFieldBoosts(String)} with the 'qf' * parameter. Falls back to the 'df' parameter or * {@link org.apache.solr.schema.IndexSchema#getDefaultSearchFieldName()}. */ public static Map<String, Float> parseQueryFields(final IndexSchema indexSchema, final SolrParams solrParams) throws ParseException { final Map<String, Float> queryFields = SolrPluginUtils.parseFieldBoosts(solrParams.getParams(SirenParams.QF)); if (queryFields.isEmpty()) { final String df = QueryParsing.getDefaultField(indexSchema, solrParams.get(CommonParams.DF)); if (df == null) { throw new ParseException("Neither "+SirenParams.QF+", "+CommonParams.DF +", nor the default search field are present."); } queryFields.put(df, 1.0f); } checkFieldTypes(indexSchema, queryFields); return queryFields; }
@Override public SortSpec getSort(boolean useGlobal) throws ParseException { SortSpec sort = super.getSort(useGlobal); if (sortStr != null && sortStr.length()>0 && sort.getSort()==null) { Sort oldSort = QueryParsing.parseSort(sortStr, getReq().getSchema()); if( oldSort != null ) { sort.sort = oldSort; } } return sort; }
/** * Given a string containing functions with optional boosts, returns * an array of Queries representing those functions with the specified * boosts. * <p> * NOTE: intra-function whitespace is not allowed. * </p> * @see #parseFieldBoosts * @deprecated */ public static List<Query> parseFuncs(IndexSchema s, String in) throws ParseException { Map<String,Float> ff = parseFieldBoosts(in); List<Query> funcs = new ArrayList<Query>(ff.keySet().size()); for (String f : ff.keySet()) { Query fq = QueryParsing.parseFunction(f, s); Float b = ff.get(f); if (null != b) { fq.setBoost(b); } funcs.add(fq); } return funcs; }
/** * "foo" returns null * "{!prefix f=myfield}yes" returns type="prefix",f="myfield",v="yes" * "{!prefix f=myfield v=$p}" returns type="prefix",f="myfield",v=params.get("p") */ public static SolrParams getLocalParams(String txt, SolrParams params) throws ParseException { if (txt==null || !txt.startsWith(LOCALPARAM_START)) { return null; } Map<String,String> localParams = new HashMap<String,String>(); int start = QueryParsing.parseLocalParams(txt, 0, localParams, params); String val; if (start >= txt.length()) { // if the rest of the string is empty, check for "v" to provide the value val = localParams.get(V); val = val==null ? "" : val; } else { val = txt.substring(start); } localParams.put(V,val); return new MapSolrParams(localParams); }
SortSpec sortSpec() throws SyntaxError { if (sortSpec == null) { sortSpec = qParser != null ? qParser.getSort(true) : QueryParsing.parseSortSpec("id asc", request); sortSpec.setOffset(0); } return sortSpec; }
@Override public Query parse() throws SyntaxError { String qstr = getString(); String defaultField = getParam(CommonParams.DF); XpathQueryParser queryParser = new XpathQueryParser(this, defaultField); queryParser.setDefaultOperator(QueryParsing.parseOP(getParam(QueryParsing.OP))); return queryParser.parse(qstr); }
/** * Formats a Query for debugging, using the IndexSchema to make * complex field types readable. * * <p> * The benefit of using this method instead of calling * <code>Query.toString</code> directly is that it knows about the data * types of each field, so any field which is encoded in a particularly * complex way is still readable. The downside is that it only knows * about built in Query types, and will not be able to format custom * Query classes. * </p> */ public static String toString(Query query, IndexSchema schema) { try { StringBuilder sb = new StringBuilder(); toString(query, schema, sb, 0); return sb.toString(); } catch (Exception e) { throw new RuntimeException(e); } }
query = QueryParsing.parseQuery(qs, req.getSchema()); sort = QueryParsing.parseSort(commands.get(1), req.getSchema());
public FacetBase(ResponseBuilder rb, String facetType, String facetStr) { this.facetType = facetType; this.facetStr = facetStr; try { this.localParams = QueryParsing.getLocalParams(facetStr, rb.req.getParams()); } catch (ParseException e) { throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, e); } this.facetOn = facetStr; this.key = facetStr; if (localParams != null) { // remove local params unless it's a query if (!facetType.equals(FacetParams.FACET_QUERY)) { facetOn = localParams.get(CommonParams.VALUE); key = facetOn; } key = localParams.get(CommonParams.OUTPUT_KEY, key); } }
/** * Uses {@link SolrPluginUtils#parseFieldBoosts(String)} with the 'qf' * parameter. Falls back to the 'df' parameter or * {@link org.apache.solr.schema.IndexSchema#getDefaultSearchFieldName()}. */ public static Map<String, Float> parseQueryFields(final IndexSchema indexSchema, final SolrParams solrParams) throws SyntaxError { final Map<String, Float> queryFields = SolrPluginUtils.parseFieldBoosts(solrParams.getParams(SirenParams.QF)); if (queryFields.isEmpty()) { final String df = QueryParsing.getDefaultField(indexSchema, solrParams.get(CommonParams.DF)); if (df == null) { throw new SyntaxError("Neither "+SirenParams.QF+", "+CommonParams.DF +", nor the default search field are present."); } queryFields.put(df, 1.0f); } checkFieldTypes(indexSchema, queryFields); return queryFields; }
/** * Determines the correct Sort based on the request parameter "sort" * * @return null if no sort is specified. */ public static Sort getSort(SolrQueryRequest req) { String sort = req.getParams().get(org.apache.solr.common.params.CommonParams.SORT); if (null == sort || sort.equals("")) { return null; } SolrException sortE = null; Sort ss = null; try { ss = QueryParsing.parseSort(sort, req.getSchema()); } catch (SolrException e) { sortE = e; } if ((null == ss) || (null != sortE)) { /* we definitely had some sort of sort string from the user, * but no SortSpec came out of it */ SolrCore.log.warn("Invalid sort \""+sort+"\" was specified, ignoring", sortE); return null; } return ss; }
protected Query getFieldQuery(String field, String queryText) throws ParseException { checkNullField(field); // intercept magic field name of "_" to use as a hook for our // own functions. if (field.charAt(0) == '_') { if ("_val_".equals(field)) { if (parser==null) { return QueryParsing.parseFunction(queryText, schema); } else { QParser nested = parser.subQuery(queryText, "func"); return nested.getQuery(); } } else if ("_query_".equals(field) && parser != null) { return parser.subQuery(queryText, null).getQuery(); } } // default to a normal field query return super.getFieldQuery(field, queryText); }
int end = QueryParsing.parseLocalParams(qs, start, nestedLocalParams, getParams());
public void addDebugInfo(NamedList<Object> debugInfo) { super.addDebugInfo(debugInfo); debugInfo.add("altquerystring", altUserQuery); if (null != boostQueries) { debugInfo.add("boost_queries", boostParams); debugInfo.add("parsed_boost_queries", QueryParsing.toString(boostQueries, req.getSchema())); } debugInfo.add("boostfuncs", req.getParams().getParams(DisMaxParams.BF)); } }