Rewrite more queries to match_none when they target an unmapped field

docs/changelog/132987.yaml

@@ -0,0 +1,6 @@
+pr: 132987
+summary: Rewrite more queries to `match_none` when they target an unmapped field
+area: Search
+type: enhancement
+issues:
+ - 97129

modules/percolator/src/main/java/org/elasticsearch/percolator/PercolatorFieldMapper.java

@@ -422,7 +422,9 @@ public void parse(DocumentParserContext context) throws IOException {
         IndexVersion indexVersion = context.indexSettings().getIndexVersionCreated();
         createQueryBuilderField(indexVersion, clusterTransportVersion.get(), queryBuilderField, queryBuilder, context);
 
-        QueryBuilder queryBuilderForProcessing = queryBuilder.rewrite(new SearchExecutionContext(executionContext));
+        SearchExecutionContext copy = new SearchExecutionContext(executionContext);
+        configureContext(copy, isMapUnmappedFieldAsText());
+        QueryBuilder queryBuilderForProcessing = queryBuilder.rewrite(copy);
         Query query = queryBuilderForProcessing.toQuery(executionContext);
         processQuery(query, context);
     }

server/src/internalClusterTest/java/org/elasticsearch/search/simple/SimpleSearchIT.java

@@ -473,7 +473,7 @@ public void testTermQueryBigInt() throws Exception {
 
     public void testTooLongRegexInRegexpQuery() throws Exception {
         createIndex("idx");
-        indexRandom(true, prepareIndex("idx").setSource("{}", XContentType.JSON));
+        indexRandom(true, prepareIndex("idx").setSource("num", "value"));
 
         int defaultMaxRegexLength = IndexSettings.MAX_REGEX_LENGTH_SETTING.get(Settings.EMPTY);
         StringBuilder regexp = new StringBuilder(defaultMaxRegexLength);

server/src/main/java/org/elasticsearch/index/query/AbstractGeometryQueryBuilder.java

@@ -460,6 +460,15 @@ protected QueryBuilder doRewrite(QueryRewriteContext queryRewriteContext) throws
             });
             return newShapeQueryBuilder(this.fieldName, supplier::get, this.indexedShapeId).relation(relation);
         }
+        return super.doRewrite(queryRewriteContext);
+    }
+
+    @Override
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
+        }
         return this;
     }
 

server/src/main/java/org/elasticsearch/index/query/BaseTermQueryBuilder.java

@@ -13,6 +13,7 @@
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.index.mapper.MappedFieldType;
 import org.elasticsearch.xcontent.ParseField;
 import org.elasticsearch.xcontent.XContentBuilder;
 
@@ -161,4 +162,17 @@ protected int doHashCode() {
     protected boolean doEquals(QB other) {
         return Objects.equals(fieldName, other.fieldName) && Objects.equals(value, other.value);
     }
+
+    @Override
+    protected final QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(this.fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query is against a field that does not exist");
+        }
+        return doIndexMetadataRewrite(context, fieldType);
+    }
+
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context, MappedFieldType fieldType) throws IOException {
+        return this;
+    }
 }

server/src/main/java/org/elasticsearch/index/query/FuzzyQueryBuilder.java

@@ -252,15 +252,12 @@ public String getWriteableName() {
     }
 
     @Override
-    protected QueryBuilder doRewrite(QueryRewriteContext queryRewriteContext) throws IOException {
-        SearchExecutionContext context = queryRewriteContext.convertToSearchExecutionContext();
-        if (context != null) {
-            MappedFieldType fieldType = context.getFieldType(fieldName);
-            if (fieldType == null) {
-                return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
-            }
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
         }
-        return super.doRewrite(context);
+        return this;
     }
 
     @Override

server/src/main/java/org/elasticsearch/index/query/GeoBoundingBoxQueryBuilder.java

@@ -384,4 +384,13 @@ public String getWriteableName() {
     public TransportVersion getMinimalSupportedVersion() {
         return TransportVersion.zero();
     }
+
+    @Override
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
+        }
+        return this;
+    }
 }

server/src/main/java/org/elasticsearch/index/query/GeoDistanceQueryBuilder.java

@@ -386,4 +386,13 @@ public String getWriteableName() {
     public TransportVersion getMinimalSupportedVersion() {
         return TransportVersion.zero();
     }
+
+    @Override
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
+        }
+        return this;
+    }
 }

server/src/main/java/org/elasticsearch/index/query/GeoPolygonQueryBuilder.java

@@ -320,4 +320,13 @@ public String getWriteableName() {
     public TransportVersion getMinimalSupportedVersion() {
         return TransportVersion.zero();
     }
+
+    @Override
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
+        }
+        return this;
+    }
 }

server/src/main/java/org/elasticsearch/index/query/MatchPhrasePrefixQueryBuilder.java

@@ -15,6 +15,7 @@
 import org.elasticsearch.common.ParsingException;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.index.mapper.MappedFieldType;
 import org.elasticsearch.index.search.MatchQueryParser;
 import org.elasticsearch.xcontent.ParseField;
 import org.elasticsearch.xcontent.XContentBuilder;
@@ -287,4 +288,13 @@ public static MatchPhrasePrefixQueryBuilder fromXContent(XContentParser parser)
     public TransportVersion getMinimalSupportedVersion() {
         return TransportVersion.zero();
     }
+
+    @Override
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
+        }
+        return this;
+    }
 }

server/src/main/java/org/elasticsearch/index/query/MatchPhraseQueryBuilder.java

@@ -164,6 +164,10 @@ protected void doXContent(XContentBuilder builder, Params params) throws IOExcep
 
     @Override
     protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query is against a field that does not exist");
+        }
         // If we're using the default keyword analyzer then we can rewrite this to a TermQueryBuilder
         // and possibly shortcut
         // If we're using a keyword analyzer then we can rewrite this to a TermQueryBuilder

server/src/main/java/org/elasticsearch/index/query/MatchQueryBuilder.java

@@ -366,6 +366,10 @@ public void doXContent(XContentBuilder builder, Params params) throws IOExceptio
 
     @Override
     protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query is against a field that does not exist");
+        }
         if (fuzziness != null || lenient) {
             // Term queries can be neither fuzzy nor lenient, so don't rewrite under these conditions
             return this;

server/src/main/java/org/elasticsearch/index/query/RangeQueryBuilder.java

@@ -480,6 +480,15 @@ protected MappedFieldType.Relation getRelation(final SearchExecutionContext sear
         );
     }
 
+    @Override
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
+        }
+        return this;
+    }
+
     @Override
     protected QueryBuilder doCoordinatorRewrite(final CoordinatorRewriteContext coordinatorRewriteContext) {
         return toQueryBuilder(getRelation(coordinatorRewriteContext));

server/src/main/java/org/elasticsearch/index/query/RegexpQueryBuilder.java

@@ -322,4 +322,13 @@ protected boolean doEquals(RegexpQueryBuilder other) {
     public TransportVersion getMinimalSupportedVersion() {
         return TransportVersion.zero();
     }
+
+    @Override
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
+        }
+        return this;
+    }
 }

server/src/main/java/org/elasticsearch/index/query/TermQueryBuilder.java

@@ -166,11 +166,7 @@ protected void addExtraXContent(XContentBuilder builder, Params params) throws I
     }
 
     @Override
-    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) {
-        MappedFieldType fieldType = context.getFieldType(this.fieldName);
-        if (fieldType == null) {
-            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query is against a field that does not exist");
-        }
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context, MappedFieldType fieldType) throws IOException {
         return maybeRewriteBasedOnConstantFields(fieldType, context);
     }
 

server/src/main/java/org/elasticsearch/index/query/TermsSetQueryBuilder.java

@@ -266,6 +266,15 @@ public static TermsSetQueryBuilder fromXContent(XContentParser parser) throws IO
         return queryBuilder;
     }
 
+    @Override
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) throws IOException {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
+        }
+        return this;
+    }
+
     @Override
     protected Query doToQuery(SearchExecutionContext context) {
         if (values.isEmpty()) {

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

@@ -9,10 +9,12 @@
 
 package org.elasticsearch.index.query;
 
+import org.apache.lucene.search.MatchNoDocsQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.RegexpQuery;
 import org.elasticsearch.common.ParsingException;
 import org.elasticsearch.core.Strings;
+import org.elasticsearch.index.mapper.MappedFieldType;
 import org.elasticsearch.test.AbstractQueryTestCase;
 
 import java.io.IOException;
@@ -72,11 +74,15 @@ private static RegexpQueryBuilder randomRegexpQuery() {
 
     @Override
     protected void doAssertLuceneQuery(RegexpQueryBuilder queryBuilder, Query query, SearchExecutionContext context) throws IOException {
-        assertThat(query, instanceOf(RegexpQuery.class));
-        RegexpQuery regexpQuery = (RegexpQuery) query;
-
-        String expectedFieldName = expectedFieldName(queryBuilder.fieldName());
-        assertThat(regexpQuery.getField(), equalTo(expectedFieldName));
+        MappedFieldType fieldType = context.getFieldType(queryBuilder.fieldName());
+        if (fieldType == null) {
+            assertThat(query, instanceOf(MatchNoDocsQuery.class));
+        } else {
+            assertThat(query, instanceOf(RegexpQuery.class));
+            RegexpQuery regexpQuery = (RegexpQuery) query;
+            String expectedFieldName = expectedFieldName(queryBuilder.fieldName());
+            assertThat(regexpQuery.getField(), equalTo(expectedFieldName));
+        }
     }
 
     public void testIllegalArguments() {

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

@@ -12,12 +12,12 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.queries.spans.SpanTermQuery;
 import org.apache.lucene.search.BoostQuery;
+import org.apache.lucene.search.MatchNoDocsQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.TermQuery;
 import org.elasticsearch.common.ParsingException;
 import org.elasticsearch.index.mapper.IdFieldMapper;
 import org.elasticsearch.index.mapper.MappedFieldType;
-import org.elasticsearch.lucene.queries.SpanMatchNoDocsQuery;
 import org.elasticsearch.xcontent.json.JsonStringEncoder;
 
 import java.io.IOException;
@@ -58,7 +58,7 @@ protected void doAssertLuceneQuery(SpanTermQueryBuilder queryBuilder, Query quer
             Term term = ((TermQuery) mapper.termQuery(queryBuilder.value(), null)).getTerm();
             assertThat(spanTermQuery.getTerm(), equalTo(term));
         } else {
-            assertThat(query, instanceOf(SpanMatchNoDocsQuery.class));
+            assertThat(query, instanceOf(MatchNoDocsQuery.class));
         }
     }
 

x-pack/plugin/spatial/src/main/java/org/elasticsearch/xpack/spatial/index/query/GeoGridQueryBuilder.java

@@ -27,6 +27,9 @@
 import org.elasticsearch.index.mapper.GeoShapeQueryable;
 import org.elasticsearch.index.mapper.MappedFieldType;
 import org.elasticsearch.index.query.AbstractQueryBuilder;
+import org.elasticsearch.index.query.MatchNoneQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryRewriteContext;
 import org.elasticsearch.index.query.QueryShardException;
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.search.aggregations.bucket.geogrid.GeoTileUtils;
@@ -402,4 +405,13 @@ public String getWriteableName() {
     public TransportVersion getMinimalSupportedVersion() {
         return TransportVersions.V_8_3_0;
     }
+
+    @Override
+    protected QueryBuilder doIndexMetadataRewrite(QueryRewriteContext context) {
+        MappedFieldType fieldType = context.getFieldType(fieldName);
+        if (fieldType == null) {
+            return new MatchNoneQueryBuilder("The \"" + getName() + "\" query was rewritten to a \"match_none\" query.");
+        }
+        return this;
+    }
 }