Skip to content

Apache Lucene open-source search software

MultiFieldQueryParser: default operator is not honored between term positions (#16446)

Olivier Jaquemetc71ef11c549d
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 399d3b3aa2a..56dc284fb4f 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -129,6 +129,8 @@ API Changes
so that per-file bookkeeping in subclasses applies to copied files; subclasses that want an
optimized copy (e.g. HardlinkCopyDirectoryWrapper) may override to delegate. (Tim Allison)
+* GITHUB#16441: Remove deprecated method QueryParserBase.addMultiTermClauses (Egor Potemkin, Olivier Jaquemet)
+
* GITHUB#16779: Remove TermGroupFacetCollector and GroupFacetCollector. Use
TermGroupFacetCollectorManager, which supports concurrent search. GroupedFacetResult
and FacetEntry are now top-level types. (Luca Cavanna)
@@ -257,6 +259,10 @@ Optimizations
Bug Fixes
---------------------
+* GITHUB#16441: MultiFieldQueryParser + per-field boosts produce wrong Occur under AND default operator (Egor Potemkin, Olivier Jaquemet)
+
+* GITHUB#16443: MultiFieldQueryParser: default operator is not honored between term positions (Egor Potemkin, Olivier Jaquemet)
+
* GITHUB#16657: Fix hashCode/equals contract violation in LRUQueryCache's QueryCacheKey and account a
cached query's RAM once per distinct query. (Sagar Upadhyaya)
diff --git a/lucene/queryparser/src/generated/checksums/regenerateClassicQueryParser.json b/lucene/queryparser/src/generated/checksums/regenerateClassicQueryParser.json
index d351532f00c..18b10946710 100644
--- a/lucene/queryparser/src/generated/checksums/regenerateClassicQueryParser.json
+++ b/lucene/queryparser/src/generated/checksums/regenerateClassicQueryParser.json
@@ -1,7 +1,7 @@
{
"lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/ParseException.java": "d4f22934f0f8eb7ae70f47339cf04cac297a044b",
- "lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.java": "b88944c9c1ac6a3e6e8508a0c5ae84aad3306694",
- "lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.jj": "82890f966a2456daf2b6100d3d79f77a861a2e03",
+ "lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.java": "131825beb108a267d3f0e374f3392bb283f02e2b",
+ "lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.jj": "655505e6e190a9be3f4b2ec28962f61c2c4caec7",
"lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserConstants.java": "80d2d516553d87539dce33f732e774a67fb800ea",
"lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserTokenManager.java": "1263b08f33f1b5e8642f4733ea830b3b03628942",
"lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/Token.java": "5748b8acdf890eb94fa39c9d7ac86fc35e688438",
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/MultiFieldQueryParser.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/MultiFieldQueryParser.java
index 9633af40c7e..85b8e08b5a7 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/MultiFieldQueryParser.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/MultiFieldQueryParser.java
@@ -196,12 +196,43 @@ public class MultiFieldQueryParser extends QueryParser {
}
if (clauses.size() == 0) // happens for stopwords
return null;
- return getMultiFieldQuery(clauses);
+ // When maxTerms > 1, `clauses` holds one group per analyzed TERM POSITION
+ // (each group itself a SHOULD-combined field disjunction for that
+ // position) rather than one entry per field for a single term. These
+ // positions must be combined according to the default operator (e.g. all
+ // of them required under AND_OPERATOR), unlike field alternatives, which
+ // always stay SHOULD via getMultiFieldQuery.
+ return maxTerms > 1 ? getMultiTermPositionQuery(clauses) : getMultiFieldQuery(clauses);
}
Query q = super.getFieldQuery(field, queryText, quoted);
return q;
}
+ /**
+ * Combines the per-position field-disjunction groups built above when a single getFieldQuery call
+ * is analyzed into more than one term (e.g. because the query text reached this method as one
+ * grammar-level token — an escaped separator with no real whitespace, decompounding, CJK
+ * segmentation, synonym expansion, ...). Unlike getMultiFieldQuery (which combines field
+ * alternatives for a single term and always uses SHOULD), this honors the default operator, since
+ * every term position must be satisfied under AND_OPERATOR — matching this class's documented
+ * "all the query's terms must appear" contract regardless of how the terms reached this method.
+ */
+ protected Query getMultiTermPositionQuery(List<Query> positionGroups) throws ParseException {
+ if (positionGroups.isEmpty()) {
+ return null;
+ }
+ if (positionGroups.size() == 1) {
+ return positionGroups.get(0);
+ }
+ BooleanClause.Occur occur =
+ getDefaultOperator() == Operator.OR ? BooleanClause.Occur.SHOULD : BooleanClause.Occur.MUST;
+ BooleanQuery.Builder builder = newBooleanQuery();
+ for (Query group : positionGroups) {
+ builder.add(group, occur);
+ }
+ return builder.build();
+ }
+
@Override
protected Query getFuzzyQuery(String field, String termStr, float minSimilarity)
throws ParseException {
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.java
index a69fb588c4f..361437da043 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.java
@@ -744,7 +744,7 @@ public class QueryParser extends QueryParserBase implements QueryParserConstants
}
if (splitOnWhitespace == false) {
firstQuery = getFieldQuery(field, discardEscapeChar(text.image), false);
- addMultiTermClauses(clauses, firstQuery);
+ addClause(clauses, CONJ_NONE, MOD_NONE, firstQuery);
}
{
if ("" != null) return firstQuery;
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.jj b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.jj
index 36cedc26e54..d4260d79e6a 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.jj
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParser.jj
@@ -402,7 +402,7 @@ Query MultiTerm(String field, List<BooleanClause> clauses) : {
{
if (splitOnWhitespace == false) {
firstQuery = getFieldQuery(field, discardEscapeChar(text.image), false);
- addMultiTermClauses(clauses, firstQuery);
+ addClause(clauses, CONJ_NONE, MOD_NONE, firstQuery);
}
return firstQuery;
}
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
index 82511c48fd9..21be388d39e 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
@@ -47,7 +47,6 @@ import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.search.PrefixQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.RegexpQuery;
-import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TermRangeQuery;
import org.apache.lucene.search.WildcardQuery;
import org.apache.lucene.util.BytesRef;
@@ -390,46 +389,6 @@ public abstract class QueryParserBase extends QueryBuilder
else throw new RuntimeException("Clause cannot be both required and prohibited");
}
- /**
- * Adds clauses generated from analysis over text containing whitespace. There are no operators,
- * so the query's clauses can either be MUST (if the default operator is AND) or SHOULD (default
- * OR).
- *
- * <p>If all of the clauses in the given Query are TermQuery-s, this method flattens the result by
- * adding the TermQuery-s individually to the output clause list; otherwise, the given Query is
- * added as a single clause including its nested clauses.
- */
- protected void addMultiTermClauses(List<BooleanClause> clauses, Query q) {
- // We might have been passed a null query; the term might have been
- // filtered away by the analyzer.
- if (q == null) {
- return;
- }
- boolean allNestedTermQueries = false;
- if (q instanceof BooleanQuery bq) {
- allNestedTermQueries = true;
- for (BooleanClause clause : bq.clauses()) {
- if (!(clause.query() instanceof TermQuery)) {
- allNestedTermQueries = false;
- break;
- }
- }
- }
- if (allNestedTermQueries) {
- clauses.addAll(((BooleanQuery) q).clauses());
- } else {
- BooleanClause.Occur occur =
- operator == OR_OPERATOR ? BooleanClause.Occur.SHOULD : BooleanClause.Occur.MUST;
- if (q instanceof BooleanQuery bq) {
- for (BooleanClause clause : bq.clauses()) {
- clauses.add(newBooleanClause(clause.query(), occur));
- }
- } else {
- clauses.add(newBooleanClause(q, occur));
- }
- }
- }
-
/**
* @exception org.apache.lucene.queryparser.classic.ParseException throw in overridden method to
* disallow
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestMultiFieldQueryParser.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestMultiFieldQueryParser.java
index 95e78f3d9dd..1f399a80634 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestMultiFieldQueryParser.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestMultiFieldQueryParser.java
@@ -38,6 +38,7 @@ import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.store.Directory;
import org.apache.lucene.tests.analysis.MockAnalyzer;
import org.apache.lucene.tests.analysis.MockSynonymFilter;
+import org.apache.lucene.tests.analysis.MockTokenFilter;
import org.apache.lucene.tests.analysis.MockTokenizer;
import org.apache.lucene.tests.util.LuceneTestCase;
import org.apache.lucene.util.IOUtils;
@@ -391,4 +392,67 @@ public class TestMultiFieldQueryParser extends LuceneTestCase {
q = parser.parse("guinea pig");
assertEquals("(b:guinea t:guinea) (b:pig t:pig)", q.toString());
}
+
+ /**
+ * When several terms reach a single getFieldQuery(null, text, quoted) call because the *analyzer*
+ * alone splits the text into more than one token (no real whitespace at the grammar level), the
+ * default operator must still be honored between those term positions, per this class's own
+ * javadoc ("all the query's terms must appear" under AND_OPERATOR). Uses MockAnalyzer with
+ * MockTokenizer.SIMPLE (splits on any non-letter character, including '-').
+ */
+ public void testDefaultOperatorAppliesAcrossAnalyzerSplitTermPositions() throws Exception {
+ MultiFieldQueryParser parser =
+ new MultiFieldQueryParser(
+ new String[] {"field1", "field2"},
+ new MockAnalyzer(random(), MockTokenizer.SIMPLE, true));
+
+ // No real whitespace at the grammar level: the escaped colon keeps this as one grammar
+ // TERM token; ClassicAnalyzer splits it into two analyzed terms.
+ String queryText = QueryParser.escape("foo-bar");
+
+ parser.setDefaultOperator(QueryParserBase.OR_OPERATOR);
+ assertEquals(
+ "(field1:foo field2:foo) (field1:bar field2:bar)", parser.parse(queryText).toString());
+
+ parser.setDefaultOperator(QueryParserBase.AND_OPERATOR);
+ assertEquals(
+ "+(field1:foo field2:foo) +(field1:bar field2:bar)", parser.parse(queryText).toString());
+ }
+
+ /** Same scenario with a per-field boost, to confirm the boost survives inside each group. */
+ public void testDefaultOperatorAppliesAcrossAnalyzerSplitTermPositionsWithBoost()
+ throws Exception {
+ MultiFieldQueryParser parser =
+ new MultiFieldQueryParser(
+ new String[] {"field1", "field2"},
+ new MockAnalyzer(random(), MockTokenizer.SIMPLE, true),
+ Map.of("field1", 2.0f));
+
+ String queryText = QueryParser.escape("foo-bar");
+
+ parser.setDefaultOperator(QueryParserBase.AND_OPERATOR);
+ assertEquals(
+ "+((field1:foo)^2.0 field2:foo) +((field1:bar)^2.0 field2:bar)",
+ parser.parse(queryText).toString());
+ }
+
+ public void testDefaultOperatorAppliesStopwordNextToTerm() throws Exception {
+ MultiFieldQueryParser parser =
+ new MultiFieldQueryParser(
+ new String[] {"field1", "field2"},
+ new MockAnalyzer(
+ random(), MockTokenizer.WHITESPACE, true, MockTokenFilter.ENGLISH_STOPSET));
+ parser.setDefaultOperator(QueryParserBase.AND_OPERATOR);
+
+ String expected = "+(field1:foo field2:foo) +(field1:bar field2:bar)";
+
+ // Baseline
+ assertEquals(expected, parser.parse("+foo bar").toString());
+
+ // The issue: "the" is dropped by the analyzer, so "bar the" reaches getFieldQuery as one chunk
+ // that
+ // analyzes to a single term, hence in getMultiFieldQuery maxTerms = 1 and we are back
+ // to addMultiTermClauses issue where default operator is ignored
+ assertEquals(expected, parser.parse("+foo bar the").toString());
+ }
}
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestMultiFieldQueryParserBoostAndOperator.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestMultiFieldQueryParserBoostAndOperator.java
new file mode 100644
index 00000000000..f5b300e4b58
--- /dev/null
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestMultiFieldQueryParserBoostAndOperator.java
@@ -0,0 +1,105 @@
+/*
+ * 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.Map;
+import org.apache.lucene.analysis.standard.StandardAnalyzer;
+import org.apache.lucene.queryparser.classic.QueryParser.Operator;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.tests.util.LuceneTestCase;
+
+/** Reproduces and guards against a bug GITHUB#16441 in {@link QueryParserBase} */
+public class TestMultiFieldQueryParserBoostAndOperator extends LuceneTestCase {
+
+ private MultiFieldQueryParser boostedParser() {
+ return new MultiFieldQueryParser(
+ new String[] {"field1", "field2"}, new StandardAnalyzer(), Map.of("field1", 2.0f));
+ }
+
+ private MultiFieldQueryParser plainParser() {
+ return new MultiFieldQueryParser(new String[] {"field1", "field2"}, new StandardAnalyzer());
+ }
+
+ /** The original bug: a single analyzed term, boosted on one field, under AND. */
+ public void testSingleTermMultiTermPathWithBoostKeepsShouldClauses() throws Exception {
+ MultiFieldQueryParser parser = boostedParser();
+ String queryText = QueryParser.escape("hello !");
+
+ parser.setDefaultOperator(Operator.OR);
+ assertEquals("(field1:hello)^2.0 field2:hello", parser.parse(queryText).toString());
+
+ parser.setDefaultOperator(Operator.AND);
+ assertEquals("(field1:hello)^2.0 field2:hello", parser.parse(queryText).toString());
+ }
+
+ /** Same scenario without a boost map: must remain unaffected. */
+ public void testSingleTermMultiTermPathWithoutBoostIsUnaffected() throws Exception {
+ MultiFieldQueryParser parser = plainParser();
+ String queryText = QueryParser.escape("hello !");
+
+ parser.setDefaultOperator(Operator.AND);
+ assertEquals("field1:hello field2:hello", parser.parse(queryText).toString());
+ }
+
+ /**
+ * Regression guard: genuine multi-term input under AND must still get the per-position "+"
+ * joining. This is the case that an earlier, overly broad fix attempt (never flatten) broke.
+ */
+ public void testMultiTermStillJoinedWithDefaultOperator() throws Exception {
+ MultiFieldQueryParser parser = plainParser();
+
+ parser.setDefaultOperator(Operator.OR);
+ assertEquals(
+ "(field1:firstterm field2:firstterm) (field1:secondterm field2:secondterm)",
+ parser.parse("firstterm secondterm").toString());
+
+ parser.setDefaultOperator(Operator.AND);
+ assertEquals(
+ "+(field1:firstterm field2:firstterm) +(field1:secondterm field2:secondterm)",
+ parser.parse("firstterm secondterm").toString());
+ }
+
+ /** Same multi-term case with boosts, to make sure the per-position groups keep their boost. */
+ public void testMultiTermWithBoostStillJoinedWithDefaultOperator() throws Exception {
+ MultiFieldQueryParser parser = boostedParser();
+
+ parser.setDefaultOperator(Operator.AND);
+ assertEquals(
+ "+((field1:firstterm)^2.0 field2:firstterm) +((field1:secondterm)^2.0 field2:secondterm)",
+ parser.parse("firstterm secondterm").toString());
+ }
+
+ /**
+ * Regression guard for the gap in the first (rejected) fix attempt, which only special-cased
+ * BoostQuery: a per-field PrefixQuery leaf must be treated the same way as a boosted TermQuery,
+ * i.e. passed through with its original SHOULD occur rather than forced to MUST.
+ */
+ public void testSingleTermMultiTermPathWithPrefixQueryKeepsShouldClauses() throws Exception {
+ MultiFieldQueryParser parser = plainParser();
+ // Two escaped, whitespace-separated tokens that the analyzer reduces to a single analyzed
+ // prefix term, forcing the MultiTerm grammar path.
+ String queryText = QueryParser.escape("hel*") + " " + QueryParser.escape("!");
+
+ parser.setDefaultOperator(Operator.AND);
+ Query q = parser.parse(queryText);
+
+ // Whatever the exact PrefixQuery rendering, the two fields must remain an optional
+ // disjunction (no leading "+" on either field clause).
+ String s = q.toString();
+ assertFalse("expected no forced MUST on field clauses: " + s, s.startsWith("+"));
+ }
+}
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestQueryParser.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestQueryParser.java
index e00d3a5213a..cd39990b079 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestQueryParser.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestQueryParser.java
@@ -705,21 +705,21 @@ public class TestQueryParser extends QueryParserTestBase {
assertQueryEquals("field:(guinea pig)", a, "((+guinea +pig) cavy)");
- assertQueryEquals("+small guinea pig", a, "+small ((+guinea +pig) cavy)");
- assertQueryEquals("-small guinea pig", a, "-small ((+guinea +pig) cavy)");
- assertQueryEquals("!small guinea pig", a, "-small ((+guinea +pig) cavy)");
- assertQueryEquals("NOT small guinea pig", a, "-small ((+guinea +pig) cavy)");
- assertQueryEquals("small* guinea pig", a, "small* ((+guinea +pig) cavy)");
- assertQueryEquals("small? guinea pig", a, "small? ((+guinea +pig) cavy)");
- assertQueryEquals("\"small\" guinea pig", a, "small ((+guinea +pig) cavy)");
-
- assertQueryEquals("guinea pig +running", a, "((+guinea +pig) cavy) +running");
- assertQueryEquals("guinea pig -running", a, "((+guinea +pig) cavy) -running");
- assertQueryEquals("guinea pig !running", a, "((+guinea +pig) cavy) -running");
- assertQueryEquals("guinea pig NOT running", a, "((+guinea +pig) cavy) -running");
- assertQueryEquals("guinea pig running*", a, "((+guinea +pig) cavy) running*");
- assertQueryEquals("guinea pig running?", a, "((+guinea +pig) cavy) running?");
- assertQueryEquals("guinea pig \"running\"", a, "((+guinea +pig) cavy) running");
+ assertQueryEquals("+small guinea pig", a, "+small (((+guinea +pig) cavy))");
+ assertQueryEquals("-small guinea pig", a, "-small (((+guinea +pig) cavy))");
+ assertQueryEquals("!small guinea pig", a, "-small (((+guinea +pig) cavy))");
+ assertQueryEquals("NOT small guinea pig", a, "-small (((+guinea +pig) cavy))");
+ assertQueryEquals("small* guinea pig", a, "small* (((+guinea +pig) cavy))");
+ assertQueryEquals("small? guinea pig", a, "small? (((+guinea +pig) cavy))");
+ assertQueryEquals("\"small\" guinea pig", a, "small (((+guinea +pig) cavy))");
+
+ assertQueryEquals("guinea pig +running", a, "(((+guinea +pig) cavy)) +running");
+ assertQueryEquals("guinea pig -running", a, "(((+guinea +pig) cavy)) -running");
+ assertQueryEquals("guinea pig !running", a, "(((+guinea +pig) cavy)) -running");
+ assertQueryEquals("guinea pig NOT running", a, "(((+guinea +pig) cavy)) -running");
+ assertQueryEquals("guinea pig running*", a, "(((+guinea +pig) cavy)) running*");
+ assertQueryEquals("guinea pig running?", a, "(((+guinea +pig) cavy)) running?");
+ assertQueryEquals("guinea pig \"running\"", a, "(((+guinea +pig) cavy)) running");
assertQueryEquals("\"guinea pig\"~2", a, "\"guinea pig\" cavy");
@@ -890,9 +890,9 @@ public class TestQueryParser extends QueryParserTestBase {
assertEquals("*bersetzung uber*ung", parser.parse("*bersetzung über*ung").toString(FIELD));
parser.setAllowLeadingWildcard(false);
assertEquals(
- "motley crue motl?* cru?", parser.parse("Mötley Cr\u00fce Mötl?* Crü?").toString(FIELD));
+ "(motley crue) motl?* cru?", parser.parse("Mötley Cr\u00fce Mötl?* Crü?").toString(FIELD));
assertEquals(
- "renee zellweger ren?? zellw?ger",
+ "(renee zellweger) ren?? zellw?ger",
parser.parse("Renée Zellweger Ren?? Zellw?ger").toString(FIELD));
}
@@ -900,7 +900,8 @@ public class TestQueryParser extends QueryParserTestBase {
Analyzer a = new ASCIIAnalyzer();
QueryParser parser = new QueryParser(FIELD, a);
assertEquals("ubersetzung ubersetz*", parser.parse("übersetzung übersetz*").toString(FIELD));
- assertEquals("motley crue motl* cru*", parser.parse("Mötley Crüe Mötl* crü*").toString(FIELD));
+ assertEquals(
+ "(motley crue) motl* cru*", parser.parse("Mötley Crüe Mötl* crü*").toString(FIELD));
assertEquals("rene? zellw*", parser.parse("René? Zellw*").toString(FIELD));
}
@@ -917,10 +918,10 @@ public class TestQueryParser extends QueryParserTestBase {
assertEquals(
"ubersetzung ubersetzung~1", parser.parse("Übersetzung Übersetzung~0.9").toString(FIELD));
assertEquals(
- "motley crue motley~1 crue~2",
+ "(motley crue) motley~1 crue~2",
parser.parse("Mötley Crüe Mötley~0.75 Crüe~0.5").toString(FIELD));
assertEquals(
- "renee zellweger renee~0 zellweger~2",
+ "(renee zellweger) renee~0 zellweger~2",
parser.parse("Renée Zellweger Renée~0.9 Zellweger~").toString(FIELD));
}
@@ -1026,4 +1027,14 @@ public class TestQueryParser extends QueryParserTestBase {
return false;
}
}
+
+ @Override
+ protected String multiTermGroup(String str) {
+ return "(" + str + ")";
+ }
+
+ @Override
+ protected String multiTermGroupDAO(String str) {
+ return "+(" + str + ")";
+ }
}
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
index f51ad1e76c2..cc34601dfbc 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
@@ -588,14 +588,19 @@ public abstract class QueryParserTestBase extends LuceneTestCase {
assertQueryEquals("{ a TO z }^2.0", null, "({a TO z})^2.0");
assertQueryEquals("[ a TO z] OR bar", null, "[a TO z] bar");
assertQueryEquals("[ a TO z] AND bar", null, "+[a TO z] +bar");
- assertQueryEquals("( bar blar { a TO z}) ", null, "bar blar {a TO z}");
- assertQueryEquals("gack ( bar blar { a TO z}) ", null, "gack (bar blar {a TO z})");
+ assertQueryEquals("( bar blar { a TO z}) ", null, multiTermGroup("bar blar") + " {a TO z}");
+ assertQueryEquals(
+ "gack ( bar blar { a TO z}) ", null, "gack (" + multiTermGroup("bar blar") + " {a TO z})");
assertQueryEquals("[* TO Z]", null, "[* TO z]");
assertQueryEquals("[A TO *]", null, "[a TO *]");
assertQueryEquals("[* TO *]", null, "[* TO *]");
}
+ protected String multiTermGroup(String str) {
+ return str;
+ }
+
public void testRangeWithPhrase() throws Exception {
assertQueryEquals("[\\* TO \"*\"]", null, "[\\* TO \\*]");
assertQueryEquals("[\"*\" TO *]", null, "[\\* TO *]");
@@ -912,9 +917,13 @@ public abstract class QueryParserTestBase extends LuceneTestCase {
public void testSimpleDAO() throws Exception {
assertQueryEqualsDOA("term term term", null, "+term +term +term");
assertQueryEqualsDOA("term +term term", null, "+term +term +term");
- assertQueryEqualsDOA("term term +term", null, "+term +term +term");
+ assertQueryEqualsDOA("term term +term", null, multiTermGroupDAO("+term +term") + " +term");
assertQueryEqualsDOA("term +term +term", null, "+term +term +term");
- assertQueryEqualsDOA("-term term term", null, "-term +term +term");
+ assertQueryEqualsDOA("-term term term", null, "-term " + multiTermGroupDAO("+term +term"));
+ }
+
+ protected String multiTermGroupDAO(String str) {
+ return str;
}
public void testBoost() throws Exception {