Multi term intervals: increase max_expansions

Currently multi term interval queries (prefix, wildcard, fuzzy, regexp and range) can
expand maximum to 128 terms. To reach parity with span queries that we want to deprecate,
set max expansions to indices.query.bool.max_clause_count which is used in span queries.

Relates to #110491

Author: mayya-sharipova

docs/reference/query-dsl/intervals-query.asciidoc

@@ -124,8 +124,9 @@ unstemmed ones.
 ==== `prefix` rule parameters
 
 The `prefix` rule matches terms that start with a specified set of characters.
-This prefix can expand to match at most 128 terms. If the prefix matches more
-than 128 terms, {es} returns an error. You can use the
+This prefix can expand to match at most `indices.query.bool.max_clause_count`
+<<search-settings,search setting>> terms. If the prefix matches more terms,
+{es} returns an error. You can use the
 <<index-prefixes,`index-prefixes`>> option in the field mapping to avoid this
 limit.
 
@@ -151,7 +152,8 @@ separate `analyzer` is specified.
 ==== `wildcard` rule parameters
 
 The `wildcard` rule matches terms using a wildcard pattern. This pattern can
-expand to match at most 128 terms. If the pattern matches more than 128 terms,
+expand to match at most  `indices.query.bool.max_clause_count`
+<<search-settings,search setting>> terms. If the pattern matches more terms,
 {es} returns an error.
 
 `pattern`::
@@ -184,8 +186,9 @@ The `pattern` is normalized using the search analyzer from this field, unless
 ==== `regexp` rule parameters
 
 The `regexp` rule matches terms using a regular expression pattern.
-This pattern can expand to match at most 128 terms.
-If the pattern matches more than 128 terms,{es} returns an error.
+This pattern can expand to match at most  `indices.query.bool.max_clause_count`
+<<search-settings,search setting>> terms.
+If the pattern matches more terms,{es} returns an error.
 
 `pattern`::
 (Required, string) Regexp pattern used to find matching terms.
@@ -215,7 +218,8 @@ The `pattern` is normalized using the search analyzer from this field, unless
 
 The `fuzzy` rule matches terms that are similar to the provided term, within an
 edit distance defined by <<fuzziness>>. If the fuzzy expansion matches more than
-128 terms, {es} returns an error.
+`indices.query.bool.max_clause_count`
+<<search-settings,search setting>> terms, {es} returns an error.
 
 `term`::
 (Required, string) The term to match
@@ -250,8 +254,9 @@ The `term` is normalized using the search analyzer from this field, unless
 ==== `range` rule parameters
 
 The `range` rule matches terms contained within a provided range.
-This range can expand to match at most 128 terms.
-If the range matches more than 128 terms,{es} returns an error.
+This range can expand to match at most  `indices.query.bool.max_clause_count`
+<<search-settings,search setting>> terms.
+If the range matches more terms,{es} returns an error.
 
 `gt`::
 (Optional, string) Greater than: match terms greater than the provided term.

modules/mapper-extras/src/main/java/org/elasticsearch/index/mapper/extras/MatchOnlyTextFieldMapper.java

@@ -21,6 +21,7 @@
 import org.apache.lucene.queries.intervals.IntervalsSource;
 import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.FuzzyQuery;
+import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.PrefixQuery;
@@ -270,7 +271,11 @@ public IntervalsSource termIntervals(BytesRef term, SearchExecutionContext conte
 
         @Override
         public IntervalsSource prefixIntervals(BytesRef term, SearchExecutionContext context) {
-            return toIntervalsSource(Intervals.prefix(term), new PrefixQuery(new Term(name(), term)), context);
+            return toIntervalsSource(
+                Intervals.prefix(term, IndexSearcher.getMaxClauseCount()),
+                new PrefixQuery(new Term(name(), term)),
+                context
+            );
         }
 
         @Override
@@ -285,18 +290,18 @@ public IntervalsSource fuzzyIntervals(
                 new Term(name(), term),
                 maxDistance,
                 prefixLength,
-                128,
+                IndexSearcher.getMaxClauseCount(),
                 transpositions,
                 MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE
             );
-            IntervalsSource fuzzyIntervals = Intervals.multiterm(fuzzyQuery.getAutomata(), term);
+            IntervalsSource fuzzyIntervals = Intervals.multiterm(fuzzyQuery.getAutomata(), IndexSearcher.getMaxClauseCount(), term);
             return toIntervalsSource(fuzzyIntervals, fuzzyQuery, context);
         }
 
         @Override
         public IntervalsSource wildcardIntervals(BytesRef pattern, SearchExecutionContext context) {
             return toIntervalsSource(
-                Intervals.wildcard(pattern),
+                Intervals.wildcard(pattern, IndexSearcher.getMaxClauseCount()),
                 new MatchAllDocsQuery(), // wildcard queries can be expensive, what should the approximation be?
                 context
             );
@@ -305,7 +310,7 @@ public IntervalsSource wildcardIntervals(BytesRef pattern, SearchExecutionContex
         @Override
         public IntervalsSource regexpIntervals(BytesRef pattern, SearchExecutionContext context) {
             return toIntervalsSource(
-                Intervals.regexp(pattern),
+                Intervals.regexp(pattern, IndexSearcher.getMaxClauseCount()),
                 new MatchAllDocsQuery(), // regexp queries can be expensive, what should the approximation be?
                 context
             );
@@ -320,7 +325,7 @@ public IntervalsSource rangeIntervals(
             SearchExecutionContext context
         ) {
             return toIntervalsSource(
-                Intervals.range(lowerTerm, upperTerm, includeLower, includeUpper),
+                Intervals.range(lowerTerm, upperTerm, includeLower, includeUpper, IndexSearcher.getMaxClauseCount()),
                 new MatchAllDocsQuery(), // range queries can be expensive, what should the approximation be?
                 context
             );

server/src/main/java/org/elasticsearch/index/mapper/TextFieldMapper.java

@@ -36,6 +36,7 @@
 import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.FuzzyQuery;
+import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.MultiPhraseQuery;
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.PhraseQuery;
@@ -620,7 +621,8 @@ public IntervalsSource intervals(BytesRef term) {
                 return Intervals.fixField(name(), Intervals.term(term));
             }
             String wildcardTerm = term.utf8ToString() + "?".repeat(Math.max(0, minChars - term.length));
-            return Intervals.or(Intervals.fixField(name(), Intervals.wildcard(new BytesRef(wildcardTerm))), Intervals.term(term));
+            return Intervals.or(Intervals.fixField(name(),
+                Intervals.wildcard(new BytesRef(wildcardTerm), IndexSearcher.getMaxClauseCount())), Intervals.term(term));
         }
 
         @Override
@@ -822,7 +824,7 @@ public IntervalsSource prefixIntervals(BytesRef term, SearchExecutionContext con
             if (prefixFieldType != null) {
                 return prefixFieldType.intervals(term);
             }
-            return Intervals.prefix(term);
+            return Intervals.prefix(term, IndexSearcher.getMaxClauseCount());
         }
 
         @Override
@@ -836,24 +838,25 @@ public IntervalsSource fuzzyIntervals(
             if (getTextSearchInfo().hasPositions() == false) {
                 throw new IllegalArgumentException("Cannot create intervals over field [" + name() + "] with no positions indexed");
             }
-            FuzzyQuery fq = new FuzzyQuery(new Term(name(), term), maxDistance, prefixLength, 128, transpositions);
-            return Intervals.multiterm(fq.getAutomata(), term);
+            FuzzyQuery fq = new FuzzyQuery(
+                new Term(name(), term), maxDistance, prefixLength, IndexSearcher.getMaxClauseCount(), transpositions);
+            return Intervals.multiterm(fq.getAutomata(), IndexSearcher.getMaxClauseCount(), term);
         }
 
         @Override
         public IntervalsSource wildcardIntervals(BytesRef pattern, SearchExecutionContext context) {
             if (getTextSearchInfo().hasPositions() == false) {
                 throw new IllegalArgumentException("Cannot create intervals over field [" + name() + "] with no positions indexed");
             }
-            return Intervals.wildcard(pattern);
+            return Intervals.wildcard(pattern, IndexSearcher.getMaxClauseCount());
         }
 
         @Override
         public IntervalsSource regexpIntervals(BytesRef pattern, SearchExecutionContext context) {
             if (getTextSearchInfo().hasPositions() == false) {
                 throw new IllegalArgumentException("Cannot create intervals over field [" + name() + "] with no positions indexed");
             }
-            return Intervals.regexp(pattern);
+            return Intervals.regexp(pattern, IndexSearcher.getMaxClauseCount());
         }
 
         @Override
@@ -867,7 +870,7 @@ public IntervalsSource rangeIntervals(
             if (getTextSearchInfo().hasPositions() == false) {
                 throw new IllegalArgumentException("Cannot create intervals over field [" + name() + "] with no positions indexed");
             }
-            return Intervals.range(lowerTerm, upperTerm, includeLower, includeUpper);
+            return Intervals.range(lowerTerm, upperTerm, includeLower, includeUpper, IndexSearcher.getMaxClauseCount());
         }
 
         private void checkForPositions() {

server/src/test/java/org/elasticsearch/index/query/IntervalQueryBuilderTests.java

@@ -9,14 +9,22 @@
 
 package org.elasticsearch.index.query;
 
+import org.apache.lucene.analysis.core.KeywordAnalyzer;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.TextField;
+import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.queries.intervals.IntervalQuery;
 import org.apache.lucene.queries.intervals.Intervals;
 import org.apache.lucene.queries.intervals.IntervalsSource;
 import org.apache.lucene.search.BoostQuery;
 import org.apache.lucene.search.FuzzyQuery;
+import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.MatchNoDocsQuery;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.tests.index.RandomIndexWriter;
 import org.apache.lucene.util.BytesRef;
 import org.elasticsearch.common.ParsingException;
 import org.elasticsearch.common.Strings;
@@ -34,7 +42,9 @@
 import java.util.Collections;
 import java.util.List;
 
+import static java.util.Collections.singleton;
 import static org.elasticsearch.xcontent.XContentFactory.jsonBuilder;
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.instanceOf;
 
@@ -606,7 +616,7 @@ public void testPrefixes() throws IOException {
               }
             }""", TEXT_FIELD_NAME);
         IntervalQueryBuilder builder = (IntervalQueryBuilder) parseQuery(json);
-        Query expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.prefix(new BytesRef("term")));
+        Query expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.prefix(new BytesRef("term"), IndexSearcher.getMaxClauseCount()));
         assertEquals(expected, builder.toQuery(createSearchExecutionContext()));
 
         String no_positions_json = Strings.format("""
@@ -667,7 +677,8 @@ public void testPrefixes() throws IOException {
         builder = (IntervalQueryBuilder) parseQuery(short_prefix_json);
         expected = new IntervalQuery(
             PREFIXED_FIELD,
-            Intervals.or(Intervals.fixField(PREFIXED_FIELD + "._index_prefix", Intervals.wildcard(new BytesRef("t?"))), Intervals.term("t"))
+            Intervals.or(Intervals.fixField(PREFIXED_FIELD + "._index_prefix",
+                Intervals.wildcard(new BytesRef("t?"), IndexSearcher.getMaxClauseCount())), Intervals.term("t"))
         );
         assertEquals(expected, builder.toQuery(createSearchExecutionContext()));
 
@@ -739,7 +750,7 @@ public void testRegexp() throws IOException {
             }""", TEXT_FIELD_NAME);
 
         IntervalQueryBuilder builder = (IntervalQueryBuilder) parseQuery(json);
-        Query expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.regexp(new BytesRef("te.*m")));
+        Query expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.regexp(new BytesRef("te.*m"), IndexSearcher.getMaxClauseCount()));
         assertEquals(expected, builder.toQuery(createSearchExecutionContext()));
 
         String no_positions_json = Strings.format("""
@@ -771,7 +782,8 @@ public void testRegexp() throws IOException {
             }""", TEXT_FIELD_NAME);
 
         builder = (IntervalQueryBuilder) parseQuery(fixed_field_json);
-        expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.fixField(MASKED_FIELD, Intervals.regexp(new BytesRef("te.*m"))));
+        expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.fixField(MASKED_FIELD,
+            Intervals.regexp(new BytesRef("te.*m"), IndexSearcher.getMaxClauseCount())));
         assertEquals(expected, builder.toQuery(createSearchExecutionContext()));
 
         String fixed_field_json_no_positions = Strings.format("""
@@ -791,6 +803,38 @@ public void testRegexp() throws IOException {
         });
     }
 
+    public void testMaxExpansionExceptionFailure() throws Exception {
+        IntervalsSourceProvider provider1 = new IntervalsSourceProvider.Prefix("bar", "keyword", null);
+        IntervalsSourceProvider provider2 = new IntervalsSourceProvider.Wildcard("bar*", "keyword", null);
+        IntervalsSourceProvider provider3 = new IntervalsSourceProvider.Fuzzy("bar", 0, true, Fuzziness.fromEdits(1), "keyword",null);
+        IntervalsSourceProvider provider4 = new IntervalsSourceProvider.Regexp("bar.*", "keyword", null);
+        IntervalsSourceProvider provider5 = new IntervalsSourceProvider.Range("bar", "bar2", true, true, "keyword", null);
+        IntervalsSourceProvider provider = randomFrom(provider1, provider2, provider3, provider4, provider5);
+
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory, new KeywordAnalyzer())) {
+                for (int i = 0; i < 3; i++) {
+                    iw.addDocument(singleton(new TextField(TEXT_FIELD_NAME, "bar" + i, Field.Store.NO)));
+                }
+                try (IndexReader reader = iw.getReader()) {
+                    int origBoolMaxClauseCount = IndexSearcher.getMaxClauseCount();
+                    IndexSearcher.setMaxClauseCount(1);
+                    try {
+
+                        IntervalQueryBuilder queryBuilder = new IntervalQueryBuilder(TEXT_FIELD_NAME, provider);
+                        IndexSearcher searcher = newSearcher(reader);
+                        Query query = queryBuilder.toQuery(createSearchExecutionContext(searcher));
+                        RuntimeException exc = expectThrows(RuntimeException.class,
+                            () ->  query.createWeight(searcher, ScoreMode.COMPLETE, 1.0f).scorer(searcher.getLeafContexts().get(0)));
+                        assertThat(exc.getMessage(), containsString("expanded to too many terms (limit 1)"));
+                    } finally {
+                        IndexSearcher.setMaxClauseCount(origBoolMaxClauseCount);
+                    }
+                }
+            }
+        }
+    }
+
     public void testWildcard() throws IOException {
         String json = Strings.format("""
             {
@@ -804,7 +848,7 @@ public void testWildcard() throws IOException {
             }""", TEXT_FIELD_NAME);
 
         IntervalQueryBuilder builder = (IntervalQueryBuilder) parseQuery(json);
-        Query expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.wildcard(new BytesRef("te?m")));
+        Query expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.wildcard(new BytesRef("te?m"), IndexSearcher.getMaxClauseCount()));
         assertEquals(expected, builder.toQuery(createSearchExecutionContext()));
 
         String no_positions_json = Strings.format("""
@@ -836,7 +880,7 @@ public void testWildcard() throws IOException {
             }""", TEXT_FIELD_NAME);
 
         builder = (IntervalQueryBuilder) parseQuery(keyword_json);
-        expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.wildcard(new BytesRef("Te?m")));
+        expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.wildcard(new BytesRef("Te?m"), IndexSearcher.getMaxClauseCount()));
         assertEquals(expected, builder.toQuery(createSearchExecutionContext()));
 
         String fixed_field_json = Strings.format("""
@@ -852,7 +896,8 @@ public void testWildcard() throws IOException {
             }""", TEXT_FIELD_NAME);
 
         builder = (IntervalQueryBuilder) parseQuery(fixed_field_json);
-        expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.fixField(MASKED_FIELD, Intervals.wildcard(new BytesRef("te?m"))));
+        expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.fixField(MASKED_FIELD,
+            Intervals.wildcard(new BytesRef("te?m"), IndexSearcher.getMaxClauseCount())));
         assertEquals(expected, builder.toQuery(createSearchExecutionContext()));
 
         String fixed_field_json_no_positions = Strings.format("""
@@ -885,13 +930,15 @@ public void testWildcard() throws IOException {
             }""", TEXT_FIELD_NAME);
 
         builder = (IntervalQueryBuilder) parseQuery(fixed_field_analyzer_json);
-        expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.fixField(MASKED_FIELD, Intervals.wildcard(new BytesRef("Te?m"))));
+        expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.fixField(MASKED_FIELD,
+            Intervals.wildcard(new BytesRef("Te?m"), IndexSearcher.getMaxClauseCount())));
         assertEquals(expected, builder.toQuery(createSearchExecutionContext()));
     }
 
     private static IntervalsSource buildFuzzySource(String term, String label, int prefixLength, boolean transpositions, int editDistance) {
-        FuzzyQuery fq = new FuzzyQuery(new Term("field", term), editDistance, prefixLength, 128, transpositions);
-        return Intervals.multiterm(fq.getAutomata(), label);
+        FuzzyQuery fq =
+            new FuzzyQuery(new Term("field", term), editDistance, prefixLength, IndexSearcher.getMaxClauseCount(), transpositions);
+        return Intervals.multiterm(fq.getAutomata(), IndexSearcher.getMaxClauseCount(), label);
     }
 
     public void testFuzzy() throws IOException {
@@ -1011,7 +1058,8 @@ public void testRange() throws IOException {
               }
             }""", TEXT_FIELD_NAME);
         IntervalQueryBuilder builder = (IntervalQueryBuilder) parseQuery(json);
-        Query expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.range(new BytesRef("aaa"), new BytesRef("aab"), true, true));
+        Query expected = new IntervalQuery(TEXT_FIELD_NAME,
+            Intervals.range(new BytesRef("aaa"), new BytesRef("aab"), true, true, IndexSearcher.getMaxClauseCount()));
         assertEquals(expected, builder.toQuery(createSearchExecutionContext()));
 
         json = Strings.format("""
@@ -1026,7 +1074,8 @@ public void testRange() throws IOException {
               }
             }""", TEXT_FIELD_NAME);
         builder = (IntervalQueryBuilder) parseQuery(json);
-        expected = new IntervalQuery(TEXT_FIELD_NAME, Intervals.range(new BytesRef("aaa"), new BytesRef("aab"), false, false));
+        expected = new IntervalQuery(TEXT_FIELD_NAME,
+            Intervals.range(new BytesRef("aaa"), new BytesRef("aab"), false, false, IndexSearcher.getMaxClauseCount()));
         assertEquals(expected, builder.toQuery(createSearchExecutionContext()));
 
         String incomplete_range = Strings.format("""