Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.solr.client.solrj; import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.List; import java.util.Locale; import java.util.regex.Pattern; import org.apache.solr.common.params.CommonParams; import org.apache.solr.common.params.FacetParams; import org.apache.solr.common.params.HighlightParams; import org.apache.solr.common.params.ModifiableSolrParams; import org.apache.solr.common.params.MoreLikeThisParams; import org.apache.solr.common.params.StatsParams; import org.apache.solr.common.params.TermsParams; /** * This is an augmented SolrParams with get/set/add fields for common fields used * in the Standard and Dismax request handlers * * * @since solr 1.3 */ public class SolrQuery extends ModifiableSolrParams { public static final String DOCID = "_docid_"; // duplicate of org.apache.solr.search.SortSpecParsing.DOCID which is not accessible from here public enum ORDER { desc, asc; public ORDER reverse() { return (this == asc) ? desc : asc; } } /** Maintains a map of current sorts */ private List<SortClause> sortClauses; public SolrQuery() { super(); } /** Create a new SolrQuery * * @param q query string */ public SolrQuery(String q) { this(); this.set(CommonParams.Q, q); } public SolrQuery(String k, String v, String... params) { assert params.length % 2 == 0; this.set(k, v); for (int i = 0; i < params.length; i += 2) { this.set(params[i], params[i + 1]); } } /** enable/disable terms. * * @param b flag to indicate terms should be enabled. <br> if b==false, removes all other terms parameters * @return Current reference (<i>this</i>) */ public SolrQuery setTerms(boolean b) { if (b) { this.set(TermsParams.TERMS, true); } else { this.remove(TermsParams.TERMS); this.remove(TermsParams.TERMS_FIELD); this.remove(TermsParams.TERMS_LOWER); this.remove(TermsParams.TERMS_UPPER); this.remove(TermsParams.TERMS_UPPER_INCLUSIVE); this.remove(TermsParams.TERMS_LOWER_INCLUSIVE); this.remove(TermsParams.TERMS_LIMIT); this.remove(TermsParams.TERMS_PREFIX_STR); this.remove(TermsParams.TERMS_MINCOUNT); this.remove(TermsParams.TERMS_MAXCOUNT); this.remove(TermsParams.TERMS_RAW); this.remove(TermsParams.TERMS_SORT); this.remove(TermsParams.TERMS_REGEXP_STR); this.remove(TermsParams.TERMS_REGEXP_FLAG); } return this; } public boolean getTerms() { return this.getBool(TermsParams.TERMS, false); } public SolrQuery addTermsField(String field) { this.add(TermsParams.TERMS_FIELD, field); return this; } public String[] getTermsFields() { return this.getParams(TermsParams.TERMS_FIELD); } public SolrQuery setTermsLower(String lower) { this.set(TermsParams.TERMS_LOWER, lower); return this; } public String getTermsLower() { return this.get(TermsParams.TERMS_LOWER, ""); } public SolrQuery setTermsUpper(String upper) { this.set(TermsParams.TERMS_UPPER, upper); return this; } public String getTermsUpper() { return this.get(TermsParams.TERMS_UPPER, ""); } public SolrQuery setTermsUpperInclusive(boolean b) { this.set(TermsParams.TERMS_UPPER_INCLUSIVE, b); return this; } public boolean getTermsUpperInclusive() { return this.getBool(TermsParams.TERMS_UPPER_INCLUSIVE, false); } public SolrQuery setTermsLowerInclusive(boolean b) { this.set(TermsParams.TERMS_LOWER_INCLUSIVE, b); return this; } public boolean getTermsLowerInclusive() { return this.getBool(TermsParams.TERMS_LOWER_INCLUSIVE, true); } public SolrQuery setTermsLimit(int limit) { this.set(TermsParams.TERMS_LIMIT, limit); return this; } public int getTermsLimit() { return this.getInt(TermsParams.TERMS_LIMIT, 10); } public SolrQuery setTermsMinCount(int cnt) { this.set(TermsParams.TERMS_MINCOUNT, cnt); return this; } public int getTermsMinCount() { return this.getInt(TermsParams.TERMS_MINCOUNT, 1); } public SolrQuery setTermsMaxCount(int cnt) { this.set(TermsParams.TERMS_MAXCOUNT, cnt); return this; } public int getTermsMaxCount() { return this.getInt(TermsParams.TERMS_MAXCOUNT, -1); } public SolrQuery setTermsPrefix(String prefix) { this.set(TermsParams.TERMS_PREFIX_STR, prefix); return this; } public String getTermsPrefix() { return this.get(TermsParams.TERMS_PREFIX_STR, ""); } public SolrQuery setTermsRaw(boolean b) { this.set(TermsParams.TERMS_RAW, b); return this; } public boolean getTermsRaw() { return this.getBool(TermsParams.TERMS_RAW, false); } public SolrQuery setTermsSortString(String type) { this.set(TermsParams.TERMS_SORT, type); return this; } public String getTermsSortString() { return this.get(TermsParams.TERMS_SORT, TermsParams.TERMS_SORT_COUNT); } public SolrQuery setTermsRegex(String regex) { this.set(TermsParams.TERMS_REGEXP_STR, regex); return this; } public String getTermsRegex() { return this.get(TermsParams.TERMS_REGEXP_STR); } public SolrQuery setTermsRegexFlag(String flag) { this.add(TermsParams.TERMS_REGEXP_FLAG, flag); return this; } public String[] getTermsRegexFlags() { return this.getParams(TermsParams.TERMS_REGEXP_FLAG); } /** Add field(s) for facet computation. * * @param fields Array of field names from the IndexSchema * @return this */ public SolrQuery addFacetField(String... fields) { add(FacetParams.FACET_FIELD, fields); this.set(FacetParams.FACET, true); return this; } /** Add field(s) for pivot computation. * * pivot fields are comma separated * * @param fields Array of field names from the IndexSchema * @return this */ public SolrQuery addFacetPivotField(String... fields) { add(FacetParams.FACET_PIVOT, fields); this.set(FacetParams.FACET, true); return this; } /** * Add a numeric range facet. * * @param field The field * @param start The start of range * @param end The end of the range * @param gap The gap between each count * @return this */ public SolrQuery addNumericRangeFacet(String field, Number start, Number end, Number gap) { add(FacetParams.FACET_RANGE, field); add(String.format(Locale.ROOT, "f.%s.%s", field, FacetParams.FACET_RANGE_START), start.toString()); add(String.format(Locale.ROOT, "f.%s.%s", field, FacetParams.FACET_RANGE_END), end.toString()); add(String.format(Locale.ROOT, "f.%s.%s", field, FacetParams.FACET_RANGE_GAP), gap.toString()); this.set(FacetParams.FACET, true); return this; } /** * Add a numeric range facet. * * @param field The field * @param start The start of range * @param end The end of the range * @param gap The gap between each count * @return this */ public SolrQuery addDateRangeFacet(String field, Date start, Date end, String gap) { add(FacetParams.FACET_RANGE, field); add(String.format(Locale.ROOT, "f.%s.%s", field, FacetParams.FACET_RANGE_START), start.toInstant().toString()); add(String.format(Locale.ROOT, "f.%s.%s", field, FacetParams.FACET_RANGE_END), end.toInstant().toString()); add(String.format(Locale.ROOT, "f.%s.%s", field, FacetParams.FACET_RANGE_GAP), gap); this.set(FacetParams.FACET, true); return this; } /** * Add Interval Faceting on a field. All intervals for the same field should be included * in the same call to this method. * For syntax documentation see <a href="https://wiki.apache.org/solr/SimpleFacetParameters#Interval_Faceting">Solr wiki</a>. * <br> * Key substitution, filter exclusions or other local params on the field are not supported when using this method, * if this is needed, use the lower level {@link #add} method.<br> * Key substitution IS supported on intervals when using this method. * * * @param field the field to add facet intervals. Must be an existing field and can't be null * @param intervals Intervals to be used for faceting. It can be an empty array, but it can't * be <code>null</code> * @return this */ public SolrQuery addIntervalFacets(String field, String[] intervals) { if (intervals == null) { throw new IllegalArgumentException("Can't add null intervals"); } if (field == null) { throw new IllegalArgumentException("Field can't be null"); } set(FacetParams.FACET, true); add(FacetParams.FACET_INTERVAL, field); for (String interval : intervals) { add(String.format(Locale.ROOT, "f.%s.facet.interval.set", field), interval); } return this; } /** * Remove all Interval Facets on a field * * @param field the field to remove from facet intervals * @return Array of current intervals for <code>field</code> */ public String[] removeIntervalFacets(String field) { while (remove(FacetParams.FACET_INTERVAL, field)) { } ; return remove(String.format(Locale.ROOT, "f.%s.facet.interval.set", field)); } /** get the facet fields * * @return string array of facet fields or null if not set/empty */ public String[] getFacetFields() { return this.getParams(FacetParams.FACET_FIELD); } /** remove a facet field * * @param name Name of the facet field to be removed. * * @return true, if the item was removed. <br> * false, if the facet field was null or did not exist. */ public boolean removeFacetField(String name) { boolean b = this.remove(FacetParams.FACET_FIELD, name); if (this.get(FacetParams.FACET_FIELD) == null && this.get(FacetParams.FACET_QUERY) == null) { this.setFacet(false); } return b; } /** enable/disable faceting. * * @param b flag to indicate faceting should be enabled. <br> if b==false, removes all other faceting parameters * @return Current reference (<i>this</i>) */ public SolrQuery setFacet(boolean b) { if (b) { this.set(FacetParams.FACET, true); } else { this.remove(FacetParams.FACET); this.remove(FacetParams.FACET_MINCOUNT); this.remove(FacetParams.FACET_FIELD); this.remove(FacetParams.FACET_LIMIT); this.remove(FacetParams.FACET_MISSING); this.remove(FacetParams.FACET_OFFSET); this.remove(FacetParams.FACET_PREFIX); this.remove(FacetParams.FACET_QUERY); this.remove(FacetParams.FACET_SORT); this.remove(FacetParams.FACET_ZEROS); this.remove(FacetParams.FACET_PREFIX); // does not include the individual fields... this.remove(FacetParams.FACET_INTERVAL); // does not remove interval parameters } return this; } public SolrQuery setFacetPrefix(String prefix) { this.set(FacetParams.FACET_PREFIX, prefix); return this; } public SolrQuery setFacetPrefix(String field, String prefix) { this.set("f." + field + "." + FacetParams.FACET_PREFIX, prefix); return this; } /** add a faceting query * * @param f facet query */ public SolrQuery addFacetQuery(String f) { this.add(FacetParams.FACET_QUERY, f); this.set(FacetParams.FACET, true); return this; } /** get facet queries * * @return all facet queries or null if not set/empty */ public String[] getFacetQuery() { return this.getParams(FacetParams.FACET_QUERY); } /** remove a facet query * * @param q the facet query to remove * @return true if the facet query was removed false otherwise */ public boolean removeFacetQuery(String q) { boolean b = this.remove(FacetParams.FACET_QUERY, q); if (this.get(FacetParams.FACET_FIELD) == null && this.get(FacetParams.FACET_QUERY) == null) { this.setFacet(false); } return b; } /** set the facet limit * * @param lim number facet items to return */ public SolrQuery setFacetLimit(int lim) { this.set(FacetParams.FACET_LIMIT, lim); return this; } /** get current facet limit * * @return facet limit or default of 25 */ public int getFacetLimit() { return this.getInt(FacetParams.FACET_LIMIT, 25); } /** set facet minimum count * * @param cnt facets having less that cnt hits will be excluded from teh facet list */ public SolrQuery setFacetMinCount(int cnt) { this.set(FacetParams.FACET_MINCOUNT, cnt); return this; } /** get facet minimum count * * @return facet minimum count or default of 1 */ public int getFacetMinCount() { return this.getInt(FacetParams.FACET_MINCOUNT, 1); } /** * Sets facet missing boolean flag * * @param v flag to indicate the field of {@link FacetParams#FACET_MISSING} . * @return this */ public SolrQuery setFacetMissing(Boolean v) { this.set(FacetParams.FACET_MISSING, v); return this; } /** get facet sort * * @return facet sort or default of {@link FacetParams#FACET_SORT_COUNT} */ public String getFacetSortString() { return this.get(FacetParams.FACET_SORT, FacetParams.FACET_SORT_COUNT); } /** set facet sort * * @param sort sort facets * @return this */ public SolrQuery setFacetSort(String sort) { this.set(FacetParams.FACET_SORT, sort); return this; } /** add highlight field * * @param f field to enable for highlighting */ public SolrQuery addHighlightField(String f) { this.add(HighlightParams.FIELDS, f); this.set(HighlightParams.HIGHLIGHT, true); return this; } /** remove a field for highlighting * * @param f field name to not highlight * @return <i>true</i>, if removed, <br> <i>false</i>, otherwise */ public boolean removeHighlightField(String f) { boolean b = this.remove(HighlightParams.FIELDS, f); if (this.get(HighlightParams.FIELDS) == null) { this.setHighlight(false); } return b; } /** get list of highlighted fields * * @return Array of highlight fields or null if not set/empty */ public String[] getHighlightFields() { return this.getParams(HighlightParams.FIELDS); } public SolrQuery setHighlightSnippets(int num) { this.set(HighlightParams.SNIPPETS, num); return this; } public int getHighlightSnippets() { return this.getInt(HighlightParams.SNIPPETS, 1); } public SolrQuery setHighlightFragsize(int num) { this.set(HighlightParams.FRAGSIZE, num); return this; } public int getHighlightFragsize() { return this.getInt(HighlightParams.FRAGSIZE, 100); } public SolrQuery setHighlightRequireFieldMatch(boolean flag) { this.set(HighlightParams.FIELD_MATCH, flag); return this; } public boolean getHighlightRequireFieldMatch() { return this.getBool(HighlightParams.FIELD_MATCH, false); } public SolrQuery setHighlightSimplePre(String f) { this.set(HighlightParams.SIMPLE_PRE, f); return this; } public String getHighlightSimplePre() { return this.get(HighlightParams.SIMPLE_PRE, ""); } public SolrQuery setHighlightSimplePost(String f) { this.set(HighlightParams.SIMPLE_POST, f); return this; } public String getHighlightSimplePost() { return this.get(HighlightParams.SIMPLE_POST, ""); } /** * Gets the raw sort field, as it will be sent to Solr. * <p> * The returned sort field will always contain a serialized version * of the sort string built using {@link #setSort(SortClause)}, * {@link #addSort(SortClause)}, {@link #addOrUpdateSort(SortClause)}, * {@link #removeSort(SortClause)}, {@link #clearSorts()} and * {@link #setSorts(List)}. */ public String getSortField() { return this.get(CommonParams.SORT); } /** * Clears current sort information. * * @return the modified SolrQuery object, for easy chaining * @since 4.2 */ public SolrQuery clearSorts() { sortClauses = null; serializeSorts(); return this; } /** * Replaces the current sort information. * * @return the modified SolrQuery object, for easy chaining * @since 4.2 */ public SolrQuery setSorts(List<SortClause> value) { sortClauses = new ArrayList<>(value); serializeSorts(); return this; } /** * Gets an a list of current sort clauses. * * @return an immutable list of current sort clauses * @since 4.2 */ public List<SortClause> getSorts() { if (sortClauses == null) return Collections.emptyList(); else return Collections.unmodifiableList(sortClauses); } /** * Replaces the current sort information with a single sort clause * * @return the modified SolrQuery object, for easy chaining * @since 4.2 */ public SolrQuery setSort(String field, ORDER order) { return setSort(new SortClause(field, order)); } /** * Replaces the current sort information with a single sort clause * * @return the modified SolrQuery object, for easy chaining * @since 4.2 */ public SolrQuery setSort(SortClause sortClause) { clearSorts(); return addSort(sortClause); } /** * Adds a single sort clause to the end of the current sort information. * * @return the modified SolrQuery object, for easy chaining * @since 4.2 */ public SolrQuery addSort(String field, ORDER order) { return addSort(new SortClause(field, order)); } /** * Adds a single sort clause to the end of the query. * * @return the modified SolrQuery object, for easy chaining * @since 4.2 */ public SolrQuery addSort(SortClause sortClause) { if (sortClauses == null) sortClauses = new ArrayList<>(); sortClauses.add(sortClause); serializeSorts(); return this; } /** * Updates or adds a single sort clause to the query. * If the field is already used for sorting, the order * of the existing field is modified; otherwise, it is * added to the end. * <p> * @return the modified SolrQuery object, for easy chaining * @since 4.2 */ public SolrQuery addOrUpdateSort(String field, ORDER order) { return addOrUpdateSort(new SortClause(field, order)); } /** * Updates or adds a single sort field specification to the current sort * information. If the sort field already exist in the sort information map, * its position is unchanged and the sort order is set; if it does not exist, * it is appended at the end with the specified order.. * * @return the modified SolrQuery object, for easy chaining * @since 4.2 */ public SolrQuery addOrUpdateSort(SortClause sortClause) { if (sortClauses != null) { for (int index = 0; index < sortClauses.size(); index++) { SortClause existing = sortClauses.get(index); if (existing.getItem().equals(sortClause.getItem())) { sortClauses.set(index, sortClause); serializeSorts(); return this; } } } return addSort(sortClause); } /** * Removes a single sort field from the current sort information. * * @return the modified SolrQuery object, for easy chaining * @since 4.2 */ public SolrQuery removeSort(SortClause sortClause) { return removeSort(sortClause.getItem()); } /** * Removes a single sort field from the current sort information. * * @return the modified SolrQuery object, for easy chaining * @since 4.2 */ public SolrQuery removeSort(String itemName) { if (sortClauses != null) { for (SortClause existing : sortClauses) { if (existing.getItem().equals(itemName)) { sortClauses.remove(existing); if (sortClauses.isEmpty()) sortClauses = null; serializeSorts(); break; } } } return this; } private void serializeSorts() { if (sortClauses == null || sortClauses.isEmpty()) { remove(CommonParams.SORT); } else { StringBuilder sb = new StringBuilder(); for (SortClause sortClause : sortClauses) { if (sb.length() > 0) sb.append(","); sb.append(sortClause.getItem()); sb.append(" "); sb.append(sortClause.getOrder()); } set(CommonParams.SORT, sb.toString()); } } public void setGetFieldStatistics(boolean v) { this.set(StatsParams.STATS, v); } public void setGetFieldStatistics(String field) { this.set(StatsParams.STATS, true); this.add(StatsParams.STATS_FIELD, field); } public void addGetFieldStatistics(String... field) { this.set(StatsParams.STATS, true); this.add(StatsParams.STATS_FIELD, field); } public void addStatsFieldFacets(String field, String... facets) { if (field == null) { this.add(StatsParams.STATS_FACET, facets); } else { for (String f : facets) { this.add("f." + field + "." + StatsParams.STATS_FACET, f); } } } public void addStatsFieldCalcDistinct(String field, boolean calcDistinct) { if (field == null) { this.add(StatsParams.STATS_CALC_DISTINCT, Boolean.toString(calcDistinct)); } else { this.add("f." + field + "." + StatsParams.STATS_CALC_DISTINCT, Boolean.toString(calcDistinct)); } } public SolrQuery setFilterQueries(String... fq) { this.set(CommonParams.FQ, fq); return this; } public SolrQuery addFilterQuery(String... fq) { this.add(CommonParams.FQ, fq); return this; } public boolean removeFilterQuery(String fq) { return this.remove(CommonParams.FQ, fq); } public String[] getFilterQueries() { return this.getParams(CommonParams.FQ); } public boolean getHighlight() { return this.getBool(HighlightParams.HIGHLIGHT, false); } public SolrQuery setHighlight(boolean b) { if (b) { this.set(HighlightParams.HIGHLIGHT, true); } else { this.remove(HighlightParams.HIGHLIGHT); this.remove(HighlightParams.FIELD_MATCH); this.remove(HighlightParams.FIELDS); this.remove(HighlightParams.FORMATTER); this.remove(HighlightParams.FRAGSIZE); this.remove(HighlightParams.SIMPLE_POST); this.remove(HighlightParams.SIMPLE_PRE); this.remove(HighlightParams.SNIPPETS); } return this; } /** * Add field for MoreLikeThis. Automatically * enables MoreLikeThis. * * @param field the names of the field to be added * @return this */ public SolrQuery addMoreLikeThisField(String field) { this.setMoreLikeThis(true); return addValueToParam(MoreLikeThisParams.SIMILARITY_FIELDS, field); } public SolrQuery setMoreLikeThisFields(String... fields) { if (fields == null || fields.length == 0) { this.remove(MoreLikeThisParams.SIMILARITY_FIELDS); this.setMoreLikeThis(false); return this; } StringBuilder sb = new StringBuilder(); sb.append(fields[0]); for (int i = 1; i < fields.length; i++) { sb.append(','); sb.append(fields[i]); } this.set(MoreLikeThisParams.SIMILARITY_FIELDS, sb.toString()); this.setMoreLikeThis(true); return this; } /** * @return an array with the fields used to compute similarity. */ public String[] getMoreLikeThisFields() { String fl = this.get(MoreLikeThisParams.SIMILARITY_FIELDS); if (fl == null || fl.length() == 0) { return null; } return fl.split(","); } /** * Sets the frequency below which terms will be ignored in the source doc * * @param mintf the minimum term frequency * @return this */ public SolrQuery setMoreLikeThisMinTermFreq(int mintf) { this.set(MoreLikeThisParams.MIN_TERM_FREQ, mintf); return this; } /** * Gets the frequency below which terms will be ignored in the source doc */ public int getMoreLikeThisMinTermFreq() { return this.getInt(MoreLikeThisParams.MIN_TERM_FREQ, 2); } /** * Sets the frequency at which words will be ignored which do not occur in * at least this many docs. * * @param mindf the minimum document frequency * @return this */ public SolrQuery setMoreLikeThisMinDocFreq(int mindf) { this.set(MoreLikeThisParams.MIN_DOC_FREQ, mindf); return this; } /** * Gets the frequency at which words will be ignored which do not occur in * at least this many docs. */ public int getMoreLikeThisMinDocFreq() { return this.getInt(MoreLikeThisParams.MIN_DOC_FREQ, 5); } /** * Sets the minimum word length below which words will be ignored. * * @param minwl the minimum word length * @return this */ public SolrQuery setMoreLikeThisMinWordLen(int minwl) { this.set(MoreLikeThisParams.MIN_WORD_LEN, minwl); return this; } /** * Gets the minimum word length below which words will be ignored. */ public int getMoreLikeThisMinWordLen() { return this.getInt(MoreLikeThisParams.MIN_WORD_LEN, 0); } /** * Sets the maximum word length above which words will be ignored. * * @param maxwl the maximum word length * @return this */ public SolrQuery setMoreLikeThisMaxWordLen(int maxwl) { this.set(MoreLikeThisParams.MAX_WORD_LEN, maxwl); return this; } /** * Gets the maximum word length above which words will be ignored. */ public int getMoreLikeThisMaxWordLen() { return this.getInt(MoreLikeThisParams.MAX_WORD_LEN, 0); } /** * Sets the maximum number of query terms that will be included in any * generated query. * * @param maxqt the maximum number of query terms * @return this */ public SolrQuery setMoreLikeThisMaxQueryTerms(int maxqt) { this.set(MoreLikeThisParams.MAX_QUERY_TERMS, maxqt); return this; } /** * Gets the maximum number of query terms that will be included in any * generated query. */ public int getMoreLikeThisMaxQueryTerms() { return this.getInt(MoreLikeThisParams.MAX_QUERY_TERMS, 25); } /** * Sets the maximum number of tokens to parse in each example doc field * that is not stored with TermVector support. * * @param maxntp the maximum number of tokens to parse * @return this */ public SolrQuery setMoreLikeThisMaxTokensParsed(int maxntp) { this.set(MoreLikeThisParams.MAX_NUM_TOKENS_PARSED, maxntp); return this; } /** * Gets the maximum number of tokens to parse in each example doc field * that is not stored with TermVector support. */ public int getMoreLikeThisMaxTokensParsed() { return this.getInt(MoreLikeThisParams.MAX_NUM_TOKENS_PARSED, 5000); } /** * Sets if the query will be boosted by the interesting term relevance. * * @param b set to true to boost the query with the interesting term relevance * @return this */ public SolrQuery setMoreLikeThisBoost(boolean b) { this.set(MoreLikeThisParams.BOOST, b); return this; } /** * Gets if the query will be boosted by the interesting term relevance. */ public boolean getMoreLikeThisBoost() { return this.getBool(MoreLikeThisParams.BOOST, false); } /** * Sets the query fields and their boosts using the same format as that * used in DisMaxQParserPlugin. These fields must also be added * using {@link #addMoreLikeThisField(String)}. * * @param qf the query fields * @return this */ public SolrQuery setMoreLikeThisQF(String qf) { this.set(MoreLikeThisParams.QF, qf); return this; } /** * Gets the query fields and their boosts. */ public String getMoreLikeThisQF() { return this.get(MoreLikeThisParams.QF); } /** * Sets the number of similar documents to return for each result. * * @param count the number of similar documents to return for each result * @return this */ public SolrQuery setMoreLikeThisCount(int count) { this.set(MoreLikeThisParams.DOC_COUNT, count); return this; } /** * Gets the number of similar documents to return for each result. */ public int getMoreLikeThisCount() { return this.getInt(MoreLikeThisParams.DOC_COUNT, MoreLikeThisParams.DEFAULT_DOC_COUNT); } /** * Enable/Disable MoreLikeThis. After enabling MoreLikeThis, the fields * used for computing similarity must be specified calling * {@link #addMoreLikeThisField(String)}. * * @param b flag to indicate if MoreLikeThis should be enabled. if b==false * removes all mlt.* parameters * @return this */ public SolrQuery setMoreLikeThis(boolean b) { if (b) { this.set(MoreLikeThisParams.MLT, true); } else { this.remove(MoreLikeThisParams.MLT); this.remove(MoreLikeThisParams.SIMILARITY_FIELDS); this.remove(MoreLikeThisParams.MIN_TERM_FREQ); this.remove(MoreLikeThisParams.MIN_DOC_FREQ); this.remove(MoreLikeThisParams.MIN_WORD_LEN); this.remove(MoreLikeThisParams.MAX_WORD_LEN); this.remove(MoreLikeThisParams.MAX_QUERY_TERMS); this.remove(MoreLikeThisParams.MAX_NUM_TOKENS_PARSED); this.remove(MoreLikeThisParams.BOOST); this.remove(MoreLikeThisParams.QF); this.remove(MoreLikeThisParams.DOC_COUNT); } return this; } /** * @return true if MoreLikeThis is enabled, false otherwise */ public boolean getMoreLikeThis() { return this.getBool(MoreLikeThisParams.MLT, false); } public SolrQuery setFields(String... fields) { if (fields == null || fields.length == 0) { this.remove(CommonParams.FL); return this; } StringBuilder sb = new StringBuilder(); sb.append(fields[0]); for (int i = 1; i < fields.length; i++) { sb.append(','); sb.append(fields[i]); } this.set(CommonParams.FL, sb.toString()); return this; } public SolrQuery addField(String field) { return addValueToParam(CommonParams.FL, field); } public String getFields() { String fields = this.get(CommonParams.FL); if (fields != null && fields.equals("score")) { fields = "*, score"; } return fields; } private static Pattern scorePattern = Pattern.compile("(^|[, ])score"); public SolrQuery setIncludeScore(boolean includeScore) { String fields = get(CommonParams.FL, "*"); if (includeScore) { if (!scorePattern.matcher(fields).find()) { this.set(CommonParams.FL, fields + ",score"); } } else { this.set(CommonParams.FL, scorePattern.matcher(fields).replaceAll("")); } return this; } public SolrQuery setQuery(String query) { this.set(CommonParams.Q, query); return this; } public String getQuery() { return this.get(CommonParams.Q); } public SolrQuery setRows(Integer rows) { if (rows == null) { this.remove(CommonParams.ROWS); } else { this.set(CommonParams.ROWS, rows); } return this; } public Integer getRows() { return this.getInt(CommonParams.ROWS); } public SolrQuery setShowDebugInfo(boolean showDebugInfo) { this.set(CommonParams.DEBUG_QUERY, String.valueOf(showDebugInfo)); return this; } public void setDistrib(boolean val) { this.set(CommonParams.DISTRIB, String.valueOf(val)); } public SolrQuery setStart(Integer start) { if (start == null) { this.remove(CommonParams.START); } else { this.set(CommonParams.START, start); } return this; } public Integer getStart() { return this.getInt(CommonParams.START); } /** * The Request Handler to use (see the solrconfig.xml), which is stored in the "qt" parameter. * Normally it starts with a '/' and if so it will be used by * {@link org.apache.solr.client.solrj.request.QueryRequest#getPath()} in the URL instead of the "qt" parameter. * If this is left blank, then the default of "/select" is assumed. * * @param qt The Request Handler name corresponding to one in solrconfig.xml on the server. * @return this */ public SolrQuery setRequestHandler(String qt) { this.set(CommonParams.QT, qt); return this; } public String getRequestHandler() { return this.get(CommonParams.QT); } /** * @return this * @see ModifiableSolrParams#set(String,String[]) */ public SolrQuery setParam(String name, String... values) { this.set(name, values); return this; } /** * @return this * @see org.apache.solr.common.params.ModifiableSolrParams#set(String, boolean) */ public SolrQuery setParam(String name, boolean value) { this.set(name, value); return this; } /** get a deep copy of this object **/ public SolrQuery getCopy() { SolrQuery q = new SolrQuery(); for (String name : this.getParameterNames()) { q.setParam(name, this.getParams(name)); } return q; } /** * Set the maximum time allowed for this query. If the query takes more time * than the specified milliseconds, a timeout occurs and partial (or no) * results may be returned. * * If given Integer is null, then this parameter is removed from the request * *@param milliseconds the time in milliseconds allowed for this query */ public SolrQuery setTimeAllowed(Integer milliseconds) { if (milliseconds == null) { this.remove(CommonParams.TIME_ALLOWED); } else { this.set(CommonParams.TIME_ALLOWED, milliseconds); } return this; } /** * Get the maximum time allowed for this query. */ public Integer getTimeAllowed() { return this.getInt(CommonParams.TIME_ALLOWED); } /////////////////////// // Utility functions /////////////////////// private String toSortString(String field, ORDER order) { return field.trim() + ' ' + String.valueOf(order).trim(); } private String join(String a, String b, String sep) { StringBuilder sb = new StringBuilder(); if (a != null && a.length() > 0) { sb.append(a); sb.append(sep); } if (b != null && b.length() > 0) { sb.append(b); } return sb.toString().trim(); } private SolrQuery addValueToParam(String name, String value) { String tmp = this.get(name); tmp = join(tmp, value, ","); this.set(name, tmp); return this; } private String join(String[] vals, String sep, String removeVal) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < vals.length; i++) { if (!vals[i].equals(removeVal)) { if (sb.length() > 0) { sb.append(sep); } sb.append(vals[i]); } } return sb.toString().trim(); } /** * A single sort clause, encapsulating what to sort and the sort order. * <p> * The item specified can be "anything sortable" by solr; some examples * include a simple field name, the constant string {@code score}, and functions * such as {@code sum(x_f, y_f)}. * <p> * A SortClause can be created through different mechanisms: * <PRE><code> * new SortClause("product", SolrQuery.ORDER.asc); * new SortClause("product", "asc"); * SortClause.asc("product"); * SortClause.desc("product"); * </code></PRE> */ public static class SortClause implements java.io.Serializable { private static final long serialVersionUID = 1L; private final String item; private final ORDER order; /** * Creates a SortClause based on item and order * @param item item to sort on * @param order direction to sort */ public SortClause(String item, ORDER order) { this.item = item; this.order = order; } /** * Creates a SortClause based on item and order * @param item item to sort on * @param order string value for direction to sort */ public SortClause(String item, String order) { this(item, ORDER.valueOf(order)); } /** * Creates an ascending SortClause for an item * @param item item to sort on */ public static SortClause create(String item, ORDER order) { return new SortClause(item, order); } /** * Creates a SortClause based on item and order * @param item item to sort on * @param order string value for direction to sort */ public static SortClause create(String item, String order) { return new SortClause(item, ORDER.valueOf(order)); } /** * Creates an ascending SortClause for an item * @param item item to sort on */ public static SortClause asc(String item) { return new SortClause(item, ORDER.asc); } /** * Creates a decending SortClause for an item * @param item item to sort on */ public static SortClause desc(String item) { return new SortClause(item, ORDER.desc); } /** * Gets the item to sort, typically a function or a fieldname * @return item to sort */ public String getItem() { return item; } /** * Gets the order to sort * @return order to sort */ public ORDER getOrder() { return order; } public boolean equals(Object other) { if (this == other) return true; if (!(other instanceof SortClause)) return false; final SortClause that = (SortClause) other; return this.getItem().equals(that.getItem()) && this.getOrder().equals(that.getOrder()); } public int hashCode() { return this.getItem().hashCode(); } /** * Gets a human readable description of the sort clause. * <p> * The returned string is not suitable for passing to Solr, * but may be useful in debug output and the like. * @return a description of the current sort clause */ public String toString() { return "[" + getClass().getSimpleName() + ": item=" + getItem() + "; order=" + getOrder() + "]"; } } }