For empty mappings use a LocalRelation (#105081)

Fixes #104809 by
converting a plan to a local relation when there is no mapping for the
index pattern.

docs/changelog/105081.yaml

@@ -0,0 +1,6 @@
+pr: 105081
+summary: For empty mappings use a `LocalRelation`
+area: ES|QL
+type: bug
+issues:
+ - 104809

x-pack/plugin/esql/qa/testFixtures/src/main/resources/stats.csv-spec

@@ -1139,12 +1139,13 @@ FROM employees
 | STATS x = CONCAT(TO_STRING(ROUND(AVG(salary % 3))), TO_STRING(MAX(emp_no))), 
         y = ROUND((MIN(emp_no / 3) + PI() - MEDIAN(salary))/E()) 
         BY z = languages % 2
+| SORT z
 ;
 
 x:s        | y:d        | z:i
-1.010029   | -16452.0   | null
 1.010100   | -15260.0   | 0
 1.010097   | -16701.0   | 1
+1.010029   | -16452.0   | null
 ;
 
 nestedAggsOverGroupingWithAlias#[skip:-8.12.99,reason:supported in 8.13]

x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/EsqlActionIT.java

@@ -10,6 +10,7 @@
 import org.elasticsearch.Build;
 import org.elasticsearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
 import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
+import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequestBuilder;
 import org.elasticsearch.action.bulk.BulkRequestBuilder;
 import org.elasticsearch.action.index.IndexRequest;
 import org.elasticsearch.action.index.IndexRequestBuilder;
@@ -1413,6 +1414,89 @@ public void testCountTextField() {
         }
     }
 
+    public void testQueryOnEmptyMappingIndex() {
+        createIndex("empty-test", Settings.EMPTY);
+        createIndex("empty-test2", Settings.EMPTY);
+        IndicesAliasesRequestBuilder indicesAliasesRequestBuilder = indicesAdmin().prepareAliases()
+            .addAliasAction(IndicesAliasesRequest.AliasActions.add().index("empty-test").alias("alias-test"))
+            .addAliasAction(IndicesAliasesRequest.AliasActions.add().index("empty-test2").alias("alias-test"));
+        indicesAdmin().aliases(indicesAliasesRequestBuilder.request()).actionGet();
+
+        String[] indexPatterns = new String[] { "empty-test", "empty-test,empty-test2", "empty-test*", "alias-test", "*-test*" };
+        String from = "FROM " + randomFrom(indexPatterns) + " ";
+
+        assertEmptyIndexQueries(from);
+
+        try (EsqlQueryResponse resp = run(from + "[METADATA _source] | EVAL x = 123")) {
+            assertFalse(resp.values().hasNext());
+            assertThat(resp.columns(), equalTo(List.of(new ColumnInfo("_source", "_source"), new ColumnInfo("x", "integer"))));
+        }
+
+        try (EsqlQueryResponse resp = run(from)) {
+            assertFalse(resp.values().hasNext());
+            assertThat(resp.columns(), equalTo(List.of(new ColumnInfo("<no-fields>", "null"))));
+        }
+    }
+
+    public void testQueryOnEmptyDataIndex() {
+        createIndex("empty_data-test", Settings.EMPTY);
+        assertAcked(client().admin().indices().prepareCreate("empty_data-test2").setMapping("name", "type=text"));
+        IndicesAliasesRequestBuilder indicesAliasesRequestBuilder = indicesAdmin().prepareAliases()
+            .addAliasAction(IndicesAliasesRequest.AliasActions.add().index("empty_data-test").alias("alias-empty_data-test"))
+            .addAliasAction(IndicesAliasesRequest.AliasActions.add().index("empty_data-test2").alias("alias-empty_data-test"));
+        indicesAdmin().aliases(indicesAliasesRequestBuilder.request()).actionGet();
+
+        String[] indexPatterns = new String[] {
+            "empty_data-test2",
+            "empty_data-test,empty_data-test2",
+            "alias-empty_data-test",
+            "*data-test" };
+        String from = "FROM " + randomFrom(indexPatterns) + " ";
+
+        assertEmptyIndexQueries(from);
+
+        try (EsqlQueryResponse resp = run(from + "[METADATA _source] | EVAL x = 123")) {
+            assertFalse(resp.values().hasNext());
+            assertThat(
+                resp.columns(),
+                equalTo(List.of(new ColumnInfo("name", "text"), new ColumnInfo("_source", "_source"), new ColumnInfo("x", "integer")))
+            );
+        }
+
+        try (EsqlQueryResponse resp = run(from)) {
+            assertFalse(resp.values().hasNext());
+            assertThat(resp.columns(), equalTo(List.of(new ColumnInfo("name", "text"))));
+        }
+    }
+
+    private void assertEmptyIndexQueries(String from) {
+        try (EsqlQueryResponse resp = run(from + "[METADATA _source] | KEEP _source | LIMIT 1")) {
+            assertFalse(resp.values().hasNext());
+            assertThat(resp.columns(), equalTo(List.of(new ColumnInfo("_source", "_source"))));
+        }
+
+        try (EsqlQueryResponse resp = run(from + "| EVAL y = 1 | KEEP y | LIMIT 1 | EVAL x = 1")) {
+            assertFalse(resp.values().hasNext());
+            assertThat(resp.columns(), equalTo(List.of(new ColumnInfo("y", "integer"), new ColumnInfo("x", "integer"))));
+        }
+
+        try (EsqlQueryResponse resp = run(from + "| STATS c = count()")) {
+            assertTrue(resp.values().hasNext());
+            Iterator<Object> row = resp.values().next();
+            assertThat(row.next(), equalTo((long) 0));
+            assertThat(resp.columns(), equalTo(List.of(new ColumnInfo("c", "long"))));
+        }
+
+        try (EsqlQueryResponse resp = run(from + "| STATS c = count() | EVAL x = 123")) {
+            assertTrue(resp.values().hasNext());
+            Iterator<Object> row = resp.values().next();
+            assertThat(row.next(), equalTo((long) 0));
+            assertThat(row.next(), equalTo(123));
+            assertFalse(row.hasNext());
+            assertThat(resp.columns(), equalTo(List.of(new ColumnInfo("c", "long"), new ColumnInfo("x", "integer"))));
+        }
+    }
+
     private void createNestedMappingIndex(String indexName) throws IOException {
         XContentBuilder builder = JsonXContent.contentBuilder();
         builder.startObject();

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/analysis/Analyzer.java

@@ -83,8 +83,10 @@
 import static org.elasticsearch.xpack.ql.type.DataTypes.NESTED;
 
 public class Analyzer extends ParameterizedRuleExecutor<LogicalPlan, AnalyzerContext> {
-    static final List<Attribute> NO_FIELDS = List.of(
-        new ReferenceAttribute(Source.EMPTY, "<no-fields>", DataTypes.NULL, null, Nullability.TRUE, null, false)
+    // marker list of attributes for plans that do not have any concrete fields to return, but have other computed columns to return
+    // ie from test | stats c = count(*)
+    public static final List<Attribute> NO_FIELDS = List.of(
+        new ReferenceAttribute(Source.EMPTY, "<no-fields>", DataTypes.NULL, null, Nullability.TRUE, null, true)
     );
     private static final Iterable<RuleExecutor.Batch<LogicalPlan>> rules;
 

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/LogicalPlanOptimizer.java

@@ -152,7 +152,8 @@ protected static List<Batch<LogicalPlan>> rules() {
             // lastly replace surrogate functions
             new SubstituteSurrogates(),
             new ReplaceRegexMatch(),
-            new ReplaceAliasingEvalWithProject()
+            new ReplaceAliasingEvalWithProject(),
+            new SkipQueryOnEmptyMappings()
             // new NormalizeAggregate(), - waits on https://github.com/elastic/elasticsearch/issues/100634
         );
 
@@ -704,6 +705,14 @@ protected LogicalPlan rule(UnaryPlan plan) {
         }
     }
 
+    static class SkipQueryOnEmptyMappings extends OptimizerRules.OptimizerRule<EsRelation> {
+
+        @Override
+        protected LogicalPlan rule(EsRelation plan) {
+            return plan.index().concreteIndices().isEmpty() ? new LocalRelation(plan.source(), plan.output(), LocalSupplier.EMPTY) : plan;
+        }
+    }
+
     @SuppressWarnings("removal")
     static class PropagateEmptyRelation extends OptimizerRules.OptimizerRule<UnaryPlan> {
 

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LocalLogicalPlanOptimizerTests.java

@@ -39,6 +39,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Set;
 
 import static java.util.Collections.emptyMap;
 import static org.elasticsearch.xpack.esql.EsqlTestUtils.L;
@@ -69,7 +70,7 @@ public static void init() {
         parser = new EsqlParser();
 
         mapping = loadMapping("mapping-basic.json");
-        EsIndex test = new EsIndex("test", mapping);
+        EsIndex test = new EsIndex("test", mapping, Set.of("test"));
         IndexResolution getIndexResult = IndexResolution.valid(test);
         logicalOptimizer = new LogicalPlanOptimizer(new LogicalOptimizerContext(EsqlTestUtils.TEST_CFG));
 
@@ -321,7 +322,7 @@ public void testSparseDocument() throws Exception {
 
         SearchStats searchStats = statsForExistingField("field000", "field001", "field002", "field003", "field004");
 
-        EsIndex index = new EsIndex("large", large);
+        EsIndex index = new EsIndex("large", large, Set.of("large"));
         IndexResolution getIndexResult = IndexResolution.valid(index);
         var logicalOptimizer = new LogicalPlanOptimizer(new LogicalOptimizerContext(EsqlTestUtils.TEST_CFG));
 

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LocalPhysicalPlanOptimizerTests.java

@@ -58,6 +58,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 import static java.util.Arrays.asList;
@@ -143,7 +144,7 @@ public void init() {
 
     private Analyzer makeAnalyzer(String mappingFileName, EnrichResolution enrichResolution) {
         var mapping = loadMapping(mappingFileName);
-        EsIndex test = new EsIndex("test", mapping);
+        EsIndex test = new EsIndex("test", mapping, Set.of("test"));
         IndexResolution getIndexResult = IndexResolution.valid(test);
 
         return new Analyzer(new AnalyzerContext(config, functionRegistry, getIndexResult, enrichResolution), new Verifier(new Metrics()));

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LogicalPlanOptimizerTests.java

@@ -15,6 +15,7 @@
 import org.elasticsearch.xpack.esql.analysis.Analyzer;
 import org.elasticsearch.xpack.esql.analysis.AnalyzerContext;
 import org.elasticsearch.xpack.esql.analysis.AnalyzerTestUtils;
+import org.elasticsearch.xpack.esql.analysis.EnrichResolution;
 import org.elasticsearch.xpack.esql.evaluator.predicate.operator.comparison.Equals;
 import org.elasticsearch.xpack.esql.evaluator.predicate.operator.comparison.GreaterThan;
 import org.elasticsearch.xpack.esql.evaluator.predicate.operator.comparison.GreaterThanOrEqual;
@@ -85,9 +86,11 @@
 
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import static java.util.Collections.emptyList;
 import static java.util.Collections.emptyMap;
+import static java.util.Collections.emptySet;
 import static java.util.Collections.singletonList;
 import static org.elasticsearch.xpack.esql.EsqlTestUtils.L;
 import static org.elasticsearch.xpack.esql.EsqlTestUtils.TEST_VERIFIER;
@@ -96,6 +99,7 @@
 import static org.elasticsearch.xpack.esql.EsqlTestUtils.loadMapping;
 import static org.elasticsearch.xpack.esql.EsqlTestUtils.localSource;
 import static org.elasticsearch.xpack.esql.EsqlTestUtils.withDefaultLimitWarning;
+import static org.elasticsearch.xpack.esql.analysis.Analyzer.NO_FIELDS;
 import static org.elasticsearch.xpack.esql.type.EsqlDataTypes.GEO_POINT;
 import static org.elasticsearch.xpack.ql.TestUtils.relation;
 import static org.elasticsearch.xpack.ql.tree.Source.EMPTY;
@@ -124,21 +128,17 @@ public class LogicalPlanOptimizerTests extends ESTestCase {
     private static Map<String, EsField> mapping;
     private static Map<String, EsField> mappingAirports;
     private static Analyzer analyzerAirports;
+    private static EnrichResolution enrichResolution;
 
     @BeforeClass
     public static void init() {
         parser = new EsqlParser();
         logicalOptimizer = new LogicalPlanOptimizer(new LogicalOptimizerContext(EsqlTestUtils.TEST_CFG));
-        var enrichResolution = AnalyzerTestUtils.loadEnrichPolicyResolution(
-            "languages_idx",
-            "id",
-            "languages_idx",
-            "mapping-languages.json"
-        );
+        enrichResolution = AnalyzerTestUtils.loadEnrichPolicyResolution("languages_idx", "id", "languages_idx", "mapping-languages.json");
 
         // Most tests used data from the test index, so we load it here, and use it in the plan() function.
         mapping = loadMapping("mapping-basic.json");
-        EsIndex test = new EsIndex("test", mapping);
+        EsIndex test = new EsIndex("test", mapping, Set.of("test"));
         IndexResolution getIndexResult = IndexResolution.valid(test);
         analyzer = new Analyzer(
             new AnalyzerContext(EsqlTestUtils.TEST_CFG, new EsqlFunctionRegistry(), getIndexResult, enrichResolution),
@@ -147,7 +147,7 @@ public static void init() {
 
         // Some tests use data from the airports index, so we load it here, and use it in the plan_airports() function.
         mappingAirports = loadMapping("mapping-airports.json");
-        EsIndex airports = new EsIndex("airports", mappingAirports);
+        EsIndex airports = new EsIndex("airports", mappingAirports, Set.of("airports"));
         IndexResolution getIndexResultAirports = IndexResolution.valid(airports);
         analyzerAirports = new Analyzer(
             new AnalyzerContext(EsqlTestUtils.TEST_CFG, new EsqlFunctionRegistry(), getIndexResultAirports, enrichResolution),
@@ -3182,6 +3182,33 @@ public void testStatsWithCanonicalAggregate() throws Exception {
         assertThat(Expressions.attribute(fields.get(1)), is(Expressions.attribute(sum_argument)));
     }
 
+    public void testEmptyMappingIndex() {
+        EsIndex empty = new EsIndex("empty_test", emptyMap(), emptySet());
+        IndexResolution getIndexResultAirports = IndexResolution.valid(empty);
+        var analyzer = new Analyzer(
+            new AnalyzerContext(EsqlTestUtils.TEST_CFG, new EsqlFunctionRegistry(), getIndexResultAirports, enrichResolution),
+            TEST_VERIFIER
+        );
+
+        var plan = logicalOptimizer.optimize(analyzer.analyze(parser.createStatement("from empty_test")));
+        as(plan, LocalRelation.class);
+        assertThat(plan.output(), equalTo(NO_FIELDS));
+
+        plan = logicalOptimizer.optimize(analyzer.analyze(parser.createStatement("from empty_test [metadata _id] | eval x = 1")));
+        as(plan, LocalRelation.class);
+        assertThat(Expressions.names(plan.output()), contains("_id", "x"));
+
+        plan = logicalOptimizer.optimize(analyzer.analyze(parser.createStatement("from empty_test [metadata _id, _version] | limit 5")));
+        as(plan, LocalRelation.class);
+        assertThat(Expressions.names(plan.output()), contains("_id", "_version"));
+
+        plan = logicalOptimizer.optimize(
+            analyzer.analyze(parser.createStatement("from empty_test | eval x = \"abc\" | enrich languages_idx on x"))
+        );
+        LocalRelation local = as(plan, LocalRelation.class);
+        assertThat(Expressions.names(local.output()), contains(NO_FIELDS.get(0).name(), "x", "language_code", "language_name"));
+    }
+
     private LogicalPlan optimizedPlan(String query) {
         return plan(query);
     }

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/PhysicalPlanOptimizerTests.java

@@ -176,7 +176,7 @@ public void init() {
         mapper = new Mapper(functionRegistry);
         // Most tests used data from the test index, so we load it here, and use it in the plan() function.
         mapping = loadMapping("mapping-basic.json");
-        EsIndex test = new EsIndex("test", mapping);
+        EsIndex test = new EsIndex("test", mapping, Set.of("test"));
         IndexResolution getIndexResult = IndexResolution.valid(test);
         var enrichResolution = setupEnrichResolution();
         analyzer = new Analyzer(new AnalyzerContext(config, functionRegistry, getIndexResult, enrichResolution), TEST_VERIFIER);
@@ -194,7 +194,7 @@ public void init() {
 
         // Some tests use data from the airports index, so we load it here, and use it in the plan_airports() function.
         mappingAirports = loadMapping("mapping-airports.json");
-        EsIndex airports = new EsIndex("airports", mappingAirports);
+        EsIndex airports = new EsIndex("airports", mappingAirports, Set.of("airports"));
         IndexResolution getIndexResultAirports = IndexResolution.valid(airports);
         analyzerAirports = new Analyzer(
             new AnalyzerContext(config, functionRegistry, getIndexResultAirports, enrichResolution),

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/planner/FilterTests.java

@@ -41,6 +41,7 @@
 import java.io.UncheckedIOException;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import static java.util.Arrays.asList;
 import static org.elasticsearch.index.query.QueryBuilders.rangeQuery;
@@ -72,7 +73,7 @@ public static void init() {
         parser = new EsqlParser();
 
         mapping = loadMapping("mapping-basic.json");
-        EsIndex test = new EsIndex("test", mapping);
+        EsIndex test = new EsIndex("test", mapping, Set.of("test"));
         IndexResolution getIndexResult = IndexResolution.valid(test);
         logicalOptimizer = new LogicalPlanOptimizer(new LogicalOptimizerContext(EsqlTestUtils.TEST_CFG));
         physicalPlanOptimizer = new PhysicalPlanOptimizer(new PhysicalOptimizerContext(EsqlTestUtils.TEST_CFG));

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/plugin/DataNodeRequestTests.java

@@ -37,6 +37,7 @@
 import java.io.IOException;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import static org.elasticsearch.xpack.esql.EsqlTestUtils.TEST_CFG;
 import static org.elasticsearch.xpack.esql.EsqlTestUtils.TEST_VERIFIER;
@@ -208,7 +209,7 @@ protected DataNodeRequest mutateInstance(DataNodeRequest in) throws IOException
 
     static LogicalPlan parse(String query) {
         Map<String, EsField> mapping = loadMapping("mapping-basic.json");
-        EsIndex test = new EsIndex("test", mapping);
+        EsIndex test = new EsIndex("test", mapping, Set.of("test"));
         IndexResolution getIndexResult = IndexResolution.valid(test);
         var logicalOptimizer = new LogicalPlanOptimizer(new LogicalOptimizerContext(TEST_CFG));
         var analyzer = new Analyzer(