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.txtindex 399d3b3aa2a..56dc284fb4f 100644--- a/lucene/CHANGES.txt+++ b/lucene/CHANGES.txt@@ -129,6 +129,8 @@ API Changesso that per-file bookkeeping in subclasses applies to copied files; subclasses that want anoptimized 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. UseTermGroupFacetCollectorManager, which supports concurrent search. GroupedFacetResultand FacetEntry are now top-level types. (Luca Cavanna)@@ -257,6 +259,10 @@ OptimizationsBug 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 acached 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.jsonindex 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.javaindex 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 stopwordsreturn 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();+ }+@Overrideprotected 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.javaindex 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.jjindex 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.javaindex 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 QueryBuilderelse 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* disallowdiff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestMultiFieldQueryParser.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/classic/TestMultiFieldQueryParser.javaindex 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.javanew file mode 100644index 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.javaindex 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.javaindex 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 {