| /* |
| * 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.lucene.queryparser.classic; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.lucene.analysis.Analyzer; |
| import org.apache.lucene.search.BooleanClause; |
| import org.apache.lucene.search.BooleanQuery; |
| import org.apache.lucene.search.BoostQuery; |
| import org.apache.lucene.search.MultiPhraseQuery; |
| import org.apache.lucene.search.PhraseQuery; |
| import org.apache.lucene.search.Query; |
| |
| /** |
| * A QueryParser which constructs queries to search multiple fields. |
| * |
| */ |
| public class MultiFieldQueryParser extends QueryParser |
| { |
| protected String[] fields; |
| protected Map<String,Float> boosts; |
| |
| /** |
| * Creates a MultiFieldQueryParser. |
| * Allows passing of a map with term to Boost, and the boost to apply to each term. |
| * |
| * <p>It will, when parse(String query) |
| * is called, construct a query like this (assuming the query consists of |
| * two terms and you specify the two fields <code>title</code> and <code>body</code>):</p> |
| * |
| * <code> |
| * (title:term1 body:term1) (title:term2 body:term2) |
| * </code> |
| * |
| * <p>When setDefaultOperator(AND_OPERATOR) is set, the result will be:</p> |
| * |
| * <code> |
| * +(title:term1 body:term1) +(title:term2 body:term2) |
| * </code> |
| * |
| * <p>When you pass a boost (title=>5 body=>10) you can get </p> |
| * |
| * <code> |
| * +(title:term1^5.0 body:term1^10.0) +(title:term2^5.0 body:term2^10.0) |
| * </code> |
| * |
| * <p>In other words, all the query's terms must appear, but it doesn't matter in |
| * what fields they appear.</p> |
| */ |
| public MultiFieldQueryParser(String[] fields, Analyzer analyzer, Map<String,Float> boosts) { |
| this(fields, analyzer); |
| this.boosts = boosts; |
| } |
| |
| /** |
| * Creates a MultiFieldQueryParser. |
| * |
| * <p>It will, when parse(String query) |
| * is called, construct a query like this (assuming the query consists of |
| * two terms and you specify the two fields <code>title</code> and <code>body</code>):</p> |
| * |
| * <code> |
| * (title:term1 body:term1) (title:term2 body:term2) |
| * </code> |
| * |
| * <p>When setDefaultOperator(AND_OPERATOR) is set, the result will be:</p> |
| * |
| * <code> |
| * +(title:term1 body:term1) +(title:term2 body:term2) |
| * </code> |
| * |
| * <p>In other words, all the query's terms must appear, but it doesn't matter in |
| * what fields they appear.</p> |
| */ |
| public MultiFieldQueryParser(String[] fields, Analyzer analyzer) { |
| super(null, analyzer); |
| this.fields = fields; |
| } |
| |
| @Override |
| protected Query getFieldQuery(String field, String queryText, int slop) throws ParseException { |
| if (field == null) { |
| List<Query> clauses = new ArrayList<>(); |
| for (int i = 0; i < fields.length; i++) { |
| Query q = super.getFieldQuery(fields[i], queryText, true); |
| if (q != null) { |
| //If the user passes a map of boosts |
| if (boosts != null) { |
| //Get the boost from the map and apply them |
| Float boost = boosts.get(fields[i]); |
| if (boost != null) { |
| q = new BoostQuery(q, boost.floatValue()); |
| } |
| } |
| q = applySlop(q,slop); |
| clauses.add(q); |
| } |
| } |
| if (clauses.size() == 0) // happens for stopwords |
| return null; |
| return getMultiFieldQuery(clauses); |
| } |
| Query q = super.getFieldQuery(field, queryText, true); |
| q = applySlop(q,slop); |
| return q; |
| } |
| |
| private Query applySlop(Query q, int slop) { |
| if (q instanceof PhraseQuery) { |
| PhraseQuery.Builder builder = new PhraseQuery.Builder(); |
| builder.setSlop(slop); |
| PhraseQuery pq = (PhraseQuery) q; |
| org.apache.lucene.index.Term[] terms = pq.getTerms(); |
| int[] positions = pq.getPositions(); |
| for (int i = 0; i < terms.length; ++i) { |
| builder.add(terms[i], positions[i]); |
| } |
| q = builder.build(); |
| } else if (q instanceof MultiPhraseQuery) { |
| MultiPhraseQuery mpq = (MultiPhraseQuery)q; |
| |
| if (slop != mpq.getSlop()) { |
| q = new MultiPhraseQuery.Builder(mpq).setSlop(slop).build(); |
| } |
| } |
| return q; |
| } |
| |
| |
| @Override |
| protected Query getFieldQuery(String field, String queryText, boolean quoted) throws ParseException { |
| if (field == null) { |
| List<Query> clauses = new ArrayList<>(); |
| Query[] fieldQueries = new Query[fields.length]; |
| int maxTerms = 0; |
| for (int i = 0; i < fields.length; i++) { |
| Query q = super.getFieldQuery(fields[i], queryText, quoted); |
| if (q != null) { |
| if (q instanceof BooleanQuery) { |
| maxTerms = Math.max(maxTerms, ((BooleanQuery)q).clauses().size()); |
| } else { |
| maxTerms = Math.max(1, maxTerms); |
| } |
| fieldQueries[i] = q; |
| } |
| } |
| for (int termNum = 0; termNum < maxTerms; termNum++) { |
| List<Query> termClauses = new ArrayList<>(); |
| for (int i = 0; i < fields.length; i++) { |
| if (fieldQueries[i] != null) { |
| Query q = null; |
| if (fieldQueries[i] instanceof BooleanQuery) { |
| List<BooleanClause> nestedClauses = ((BooleanQuery)fieldQueries[i]).clauses(); |
| if (termNum < nestedClauses.size()) { |
| q = nestedClauses.get(termNum).getQuery(); |
| } |
| } else if (termNum == 0) { // e.g. TermQuery-s |
| q = fieldQueries[i]; |
| } |
| if (q != null) { |
| if (boosts != null) { |
| //Get the boost from the map and apply them |
| Float boost = boosts.get(fields[i]); |
| if (boost != null) { |
| q = new BoostQuery(q, boost); |
| } |
| } |
| termClauses.add(q); |
| } |
| } |
| } |
| if (maxTerms > 1) { |
| if (termClauses.size() > 0) { |
| BooleanQuery.Builder builder = newBooleanQuery(); |
| for (Query termClause : termClauses) { |
| builder.add(termClause, BooleanClause.Occur.SHOULD); |
| } |
| clauses.add(builder.build()); |
| } |
| } else { |
| clauses.addAll(termClauses); |
| } |
| } |
| if (clauses.size() == 0) // happens for stopwords |
| return null; |
| return getMultiFieldQuery(clauses); |
| } |
| Query q = super.getFieldQuery(field, queryText, quoted); |
| return q; |
| } |
| |
| |
| @Override |
| protected Query getFuzzyQuery(String field, String termStr, float minSimilarity) throws ParseException |
| { |
| if (field == null) { |
| List<Query> clauses = new ArrayList<>(); |
| for (int i = 0; i < fields.length; i++) { |
| clauses.add(getFuzzyQuery(fields[i], termStr, minSimilarity)); |
| } |
| return getMultiFieldQuery(clauses); |
| } |
| return super.getFuzzyQuery(field, termStr, minSimilarity); |
| } |
| |
| @Override |
| protected Query getPrefixQuery(String field, String termStr) throws ParseException |
| { |
| if (field == null) { |
| List<Query> clauses = new ArrayList<>(); |
| for (int i = 0; i < fields.length; i++) { |
| clauses.add(getPrefixQuery(fields[i], termStr)); |
| } |
| return getMultiFieldQuery(clauses); |
| } |
| return super.getPrefixQuery(field, termStr); |
| } |
| |
| @Override |
| protected Query getWildcardQuery(String field, String termStr) throws ParseException { |
| if (field == null) { |
| List<Query> clauses = new ArrayList<>(); |
| for (int i = 0; i < fields.length; i++) { |
| clauses.add(getWildcardQuery(fields[i], termStr)); |
| } |
| return getMultiFieldQuery(clauses); |
| } |
| return super.getWildcardQuery(field, termStr); |
| } |
| |
| |
| @Override |
| protected Query getRangeQuery(String field, String part1, String part2, boolean startInclusive, boolean endInclusive) throws ParseException { |
| if (field == null) { |
| List<Query> clauses = new ArrayList<>(); |
| for (int i = 0; i < fields.length; i++) { |
| clauses.add(getRangeQuery(fields[i], part1, part2, startInclusive, endInclusive)); |
| } |
| return getMultiFieldQuery(clauses); |
| } |
| return super.getRangeQuery(field, part1, part2, startInclusive, endInclusive); |
| } |
| |
| |
| |
| @Override |
| protected Query getRegexpQuery(String field, String termStr) |
| throws ParseException { |
| if (field == null) { |
| List<Query> clauses = new ArrayList<>(); |
| for (int i = 0; i < fields.length; i++) { |
| clauses.add(getRegexpQuery(fields[i], termStr)); |
| } |
| return getMultiFieldQuery(clauses); |
| } |
| return super.getRegexpQuery(field, termStr); |
| } |
| |
| /** Creates a multifield query */ |
| // TODO: investigate more general approach by default, e.g. DisjunctionMaxQuery? |
| protected Query getMultiFieldQuery(List<Query> queries) throws ParseException { |
| if (queries.isEmpty()) { |
| return null; // all clause words were filtered away by the analyzer. |
| } |
| BooleanQuery.Builder query = newBooleanQuery(); |
| for (Query sub : queries) { |
| query.add(sub, BooleanClause.Occur.SHOULD); |
| } |
| return query.build(); |
| } |
| |
| /** |
| * Parses a query which searches on the fields specified. |
| * <p> |
| * If x fields are specified, this effectively constructs: |
| * <pre> |
| * <code> |
| * (field1:query1) (field2:query2) (field3:query3)...(fieldx:queryx) |
| * </code> |
| * </pre> |
| * @param queries Queries strings to parse |
| * @param fields Fields to search on |
| * @param analyzer Analyzer to use |
| * @throws ParseException if query parsing fails |
| * @throws IllegalArgumentException if the length of the queries array differs |
| * from the length of the fields array |
| */ |
| public static Query parse(String[] queries, String[] fields, Analyzer analyzer) throws ParseException { |
| if (queries.length != fields.length) |
| throw new IllegalArgumentException("queries.length != fields.length"); |
| BooleanQuery.Builder bQuery = new BooleanQuery.Builder(); |
| for (int i = 0; i < fields.length; i++) |
| { |
| QueryParser qp = new QueryParser(fields[i], analyzer); |
| Query q = qp.parse(queries[i]); |
| if (q!=null && // q never null, just being defensive |
| (!(q instanceof BooleanQuery) || ((BooleanQuery)q).clauses().size()>0)) { |
| bQuery.add(q, BooleanClause.Occur.SHOULD); |
| } |
| } |
| return bQuery.build(); |
| } |
| |
| /** |
| * Parses a query, searching on the fields specified. |
| * Use this if you need to specify certain fields as required, |
| * and others as prohibited. |
| * <p> |
| * Usage: |
| * <pre class="prettyprint"> |
| * <code> |
| * String[] fields = {"filename", "contents", "description"}; |
| * BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD, |
| * BooleanClause.Occur.MUST, |
| * BooleanClause.Occur.MUST_NOT}; |
| * MultiFieldQueryParser.parse("query", fields, flags, analyzer); |
| * </code> |
| * </pre> |
| *<p> |
| * The code above would construct a query: |
| * <pre> |
| * <code> |
| * (filename:query) +(contents:query) -(description:query) |
| * </code> |
| * </pre> |
| * |
| * @param query Query string to parse |
| * @param fields Fields to search on |
| * @param flags Flags describing the fields |
| * @param analyzer Analyzer to use |
| * @throws ParseException if query parsing fails |
| * @throws IllegalArgumentException if the length of the fields array differs |
| * from the length of the flags array |
| */ |
| public static Query parse(String query, String[] fields, |
| BooleanClause.Occur[] flags, Analyzer analyzer) throws ParseException { |
| if (fields.length != flags.length) |
| throw new IllegalArgumentException("fields.length != flags.length"); |
| BooleanQuery.Builder bQuery = new BooleanQuery.Builder(); |
| for (int i = 0; i < fields.length; i++) { |
| QueryParser qp = new QueryParser(fields[i], analyzer); |
| Query q = qp.parse(query); |
| if (q!=null && // q never null, just being defensive |
| (!(q instanceof BooleanQuery) || ((BooleanQuery)q).clauses().size()>0)) { |
| bQuery.add(q, flags[i]); |
| } |
| } |
| return bQuery.build(); |
| } |
| |
| /** |
| * Parses a query, searching on the fields specified. |
| * Use this if you need to specify certain fields as required, |
| * and others as prohibited. |
| * <p> |
| * Usage: |
| * <pre class="prettyprint"> |
| * <code> |
| * String[] query = {"query1", "query2", "query3"}; |
| * String[] fields = {"filename", "contents", "description"}; |
| * BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD, |
| * BooleanClause.Occur.MUST, |
| * BooleanClause.Occur.MUST_NOT}; |
| * MultiFieldQueryParser.parse(query, fields, flags, analyzer); |
| * </code> |
| * </pre> |
| *<p> |
| * The code above would construct a query: |
| * <pre> |
| * <code> |
| * (filename:query1) +(contents:query2) -(description:query3) |
| * </code> |
| * </pre> |
| * |
| * @param queries Queries string to parse |
| * @param fields Fields to search on |
| * @param flags Flags describing the fields |
| * @param analyzer Analyzer to use |
| * @throws ParseException if query parsing fails |
| * @throws IllegalArgumentException if the length of the queries, fields, |
| * and flags array differ |
| */ |
| public static Query parse(String[] queries, String[] fields, BooleanClause.Occur[] flags, |
| Analyzer analyzer) throws ParseException |
| { |
| if (!(queries.length == fields.length && queries.length == flags.length)) |
| throw new IllegalArgumentException("queries, fields, and flags array have have different length"); |
| BooleanQuery.Builder bQuery = new BooleanQuery.Builder(); |
| for (int i = 0; i < fields.length; i++) |
| { |
| QueryParser qp = new QueryParser(fields[i], analyzer); |
| Query q = qp.parse(queries[i]); |
| if (q!=null && // q never null, just being defensive |
| (!(q instanceof BooleanQuery) || ((BooleanQuery)q).clauses().size()>0)) { |
| bQuery.add(q, flags[i]); |
| } |
| } |
| return bQuery.build(); |
| } |
| |
| } |
