Merge branch 'main' into move-sql-content-from-explore-anayze-to-reference

Author: ketkee-aryamane

docs/changelog/133405.yaml

@@ -0,0 +1,5 @@
+pr: 133405
+summary: Fix wrong pruning of plans with no output columns
+area: ES|QL
+type: bug
+issues: []

docs/reference/query-languages/query-dsl/query-dsl-kql-query.md

@@ -0,0 +1,151 @@
+---
+navigation_title: "KQL"
+mapped_pages:
+  - https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-kql-query.html
+applies_to:
+  stack: preview 9.0, ga 9.1
+  serverless: all
+---
+
+# KQL query [query-dsl-kql-query]
+
+Returns documents matching a provided KQL expression. The value of the `query` parameter is parsed using the
+[Kibana Query Language (KQL)](/reference/query-languages/kql.md) and rewritten
+into standard Query DSL.
+
+Use this query when you want to accept KQL input (for example from a Kibana search bar) directly in Elasticsearch.
+
+## Example request [kql-query-example]
+
+The following example returns documents where `service.name` is `"checkout-service"` and `http.response.status_code` is `200`.
+
+```console
+GET /_search
+{
+  "query": {
+    "kql": {
+      "query": "service.name: \"checkout-service\" AND http.response.status_code: 200"
+    }
+  }
+}
+```
+
+## Top-level parameters for `kql` [kql-top-level-params]
+
+`query`
+:   (Required, string) The KQL expression to parse. See the
+[KQL language reference](/reference/query-languages/kql.md) for supported
+syntax.
+
+`case_insensitive`
+:   (Optional, boolean) If `true`, performs case-insensitive matching for field names and keyword / text terms.
+    Defaults to `false`.
+
+`default_field`
+:   (Optional, string) Default field (or field pattern with wildcards) to target when a bare term in the query
+    string does not specify a field. Supports wildcards (`*`).
+
+    Defaults to the [`index.query.default_field`](/reference/elasticsearch/index-settings/index-modules.md#index-query-default-field)
+    index setting (default value is `*`). The value `*` expands to all fields that are eligible for term queries
+    (metadata fields excluded). Searching *all* eligible fields can be expensive on mappings with many fields and
+    is subject to the `indices.query.bool.max_clause_count` limit.
+
+    Like other queries, this implicit expansion does not traverse [nested](/reference/elasticsearch/mapping-reference/nested.md)
+    documents.
+
+`time_zone`
+:   (Optional, string) [UTC offset](https://en.wikipedia.org/wiki/List_of_UTC_time_offsets) or
+    [IANA time zone](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) used to interpret date literals
+    (for example `@timestamp > now-2d`). Does not change the value of `now` (which is always system UTC) but affects
+    rounding and the interpretation of explicit date strings.
+
+`boost`
+:   (Optional, float) Standard query *boost*. Defaults to `1.0`.
+
+`_name`
+:   (Optional, string) A name to identify this query in the response's `matched_queries`.
+
+## Syntax reference
+
+The `kql` query accepts a single KQL expression string in the `query` parameter. All language elements (field matching,
+wildcards, boolean logic, ranges, nested scoping) are defined in the
+[KQL language reference](/reference/query-languages/kql.md). This page does not
+duplicate that syntax.
+
+## Additional examples [kql-examples]
+
+### Case-insensitive matching (log level)
+
+```console
+GET /_search
+{
+  "query": {
+    "kql": {
+      "query": "log.level: ErRoR",
+      "case_insensitive": true
+    }
+  }
+}
+```
+
+### Using a default field pattern
+
+Search any field under the `logs` object for the term `timeout`:
+
+```console
+GET /_search
+{
+  "query": {
+    "kql": {
+      "query": "timeout",
+      "default_field": "logs.*"
+    }
+  }
+}
+```
+
+### Date range with time zone
+
+```console
+GET /_search
+{
+  "query": {
+    "kql": {
+      "query": "@timestamp >= ""2025-10-01"" AND @timestamp < ""2025-10-02""",
+      "time_zone": "Europe/Paris"
+    }
+  }
+}
+```
+
+### Nested field query
+```console
+GET /_search
+{
+  "query": {
+    "kql": {
+      "query": "events.stack:{ file: \"app.js\" AND line: 42 }"
+    }
+  }
+}
+```
+
+## When to use `kql` vs `query_string`
+
+Use `kql` for user-facing search boxes where you want a concise, filter-oriented syntax and to avoid Lucene’s
+advanced operators (fuzzy, regexp, proximity, inline boosting). Use [`query_string`](./query-dsl-query-string-query.md)
+or [`simple_query_string`](./query-dsl-simple-query-string-query.md) when those advanced features are required.
+
+## Notes and limitations
+
+* The parsed KQL expression is rewritten into standard Query DSL and participates in scoring unless wrapped in a
+  filter context (for example inside a `bool.filter`). Adjust relevance with `boost` if needed.
+* Large wildcard expansions (in field names or terms) can hit the `indices.query.bool.max_clause_count` safeguard.
+* Nested documents require the KQL nested syntax (`path:{ ... }`); terms are not correlated across separate nested
+  objects automatically.
+* Unsupported syntax (such as fuzzy operators) results in a parse error.
+
+## See also [kql-see-also]
+
+* [KQL language reference](/reference/query-languages/kql.md)
+* [Default field setting](/reference/elasticsearch/index-settings/index-modules.md#index-query-default-field)

docs/reference/query-languages/toc.yml

@@ -22,6 +22,7 @@ toc:
           - file: query-dsl/query-dsl-multi-match-query.md
           - file: query-dsl/query-dsl-query-string-query.md
           - file: query-dsl/query-dsl-simple-query-string-query.md
+          - file: query-dsl/query-dsl-kql-query.md
       - file: query-dsl/geo-queries.md
         children:
           - file: query-dsl/query-dsl-geo-bounding-box-query.md

libs/entitlement/tools/jdk-api-extractor/src/main/java/org/elasticsearch/entitlement/tools/jdkapi/JdkApiExtractor.java

@@ -46,13 +46,13 @@ public class JdkApiExtractor {
     // exclude both final and non-final variants of these
     private static final Set<AccessibleMethod> EXCLUDES = Set.of(
         new AccessibleMethod("toString", "()Ljava/lang/String;", true, false, false),
+        new AccessibleMethod("toString", "()Ljava/lang/String;", true, true, false),
         new AccessibleMethod("hashCode", "()I", true, false, false),
+        new AccessibleMethod("hashCode", "()I", true, true, false),
         new AccessibleMethod("equals", "(Ljava/lang/Object;)Z", true, false, false),
-        new AccessibleMethod("close", "()V", true, false, false),
-        new AccessibleMethod("toString", "()Ljava/lang/String;", true, true, false),
-        new AccessibleMethod("hashCode", "()I", true, false, true),
         new AccessibleMethod("equals", "(Ljava/lang/Object;)Z", true, true, false),
-        new AccessibleMethod("close", "()V", true, false, true)
+        new AccessibleMethod("close", "()V", true, false, false),
+        new AccessibleMethod("close", "()V", true, true, false)
     );
 
     private static String DEPRECATIONS_ONLY = "--deprecations-only";
@@ -66,7 +66,7 @@ public static void main(String[] args) throws IOException {
 
         final Map<String, String> moduleNameByClass = new HashMap<>();
         final Map<ModuleClass, Set<AccessibleMethod>> accessibleImplementationsByClass = new TreeMap<>(ModuleClass.COMPARATOR);
-        final Map<ModuleClass, Set<AccessibleMethod>> accessibleForOverridesByClass = new TreeMap<>(ModuleClass.COMPARATOR);
+        final Map<ModuleClass, Set<AccessibleMethod>> inheritableAccessByClass = new TreeMap<>(ModuleClass.COMPARATOR);
         final Map<ModuleClass, Set<AccessibleMethod>> deprecationsByClass = new TreeMap<>(ModuleClass.COMPARATOR);
 
         final Map<String, Set<String>> exportsByModule = Utils.findModuleExports();
@@ -84,7 +84,7 @@ public static void main(String[] args) throws IOException {
             moduleNameByClass,
             exportsByModule,
             accessibleImplementationsByClass,
-            accessibleForOverridesByClass,
+            inheritableAccessByClass,
             deprecationsByClass
         );
         Predicate<String> modulePredicate = Utils.DEFAULT_MODULE_PREDICATE.or(
@@ -206,11 +206,11 @@ static class AccessibleClassVisitor extends ClassVisitor {
         private final Map<String, String> moduleNameByClass;
         private final Map<String, Set<String>> exportsByModule;
         private final Map<ModuleClass, Set<AccessibleMethod>> accessibleImplementationsByClass;
-        private final Map<ModuleClass, Set<AccessibleMethod>> accessibleForOverridesByClass;
+        private final Map<ModuleClass, Set<AccessibleMethod>> inheritableAccessByClass;
         private final Map<ModuleClass, Set<AccessibleMethod>> deprecationsByClass;
 
         private Set<AccessibleMethod> accessibleImplementations;
-        private Set<AccessibleMethod> accessibleForOverrides;
+        private Set<AccessibleMethod> inheritableAccess;
         private Set<AccessibleMethod> deprecations;
 
         private ModuleClass moduleClass;
@@ -223,14 +223,14 @@ static class AccessibleClassVisitor extends ClassVisitor {
             Map<String, String> moduleNameByClass,
             Map<String, Set<String>> exportsByModule,
             Map<ModuleClass, Set<AccessibleMethod>> accessibleImplementationsByClass,
-            Map<ModuleClass, Set<AccessibleMethod>> accessibleForOverridesByClass,
+            Map<ModuleClass, Set<AccessibleMethod>> inheritableAccessByClass,
             Map<ModuleClass, Set<AccessibleMethod>> deprecationsByClass
         ) {
             super(ASM9);
             this.moduleNameByClass = moduleNameByClass;
             this.exportsByModule = exportsByModule;
             this.accessibleImplementationsByClass = accessibleImplementationsByClass;
-            this.accessibleForOverridesByClass = accessibleForOverridesByClass;
+            this.inheritableAccessByClass = inheritableAccessByClass;
             this.deprecationsByClass = deprecationsByClass;
         }
 
@@ -240,21 +240,21 @@ private static Set<AccessibleMethod> newSortedSet() {
 
         @Override
         public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
-            final Set<AccessibleMethod> currentAccessibleForOverrides = newSortedSet();
+            final Set<AccessibleMethod> currentInheritedAccess = newSortedSet();
             if (superName != null) {
                 var superModuleClass = getModuleClass(superName);
                 if (accessibleImplementationsByClass.containsKey(superModuleClass) == false) {
                     visitSuperClass(superName);
                 }
-                currentAccessibleForOverrides.addAll(accessibleForOverridesByClass.getOrDefault(superModuleClass, emptySet()));
+                currentInheritedAccess.addAll(inheritableAccessByClass.getOrDefault(superModuleClass, emptySet()));
             }
             if (interfaces != null && interfaces.length > 0) {
                 for (var interfaceName : interfaces) {
                     var interfaceModuleClass = getModuleClass(interfaceName);
                     if (accessibleImplementationsByClass.containsKey(interfaceModuleClass) == false) {
                         visitInterface(interfaceName);
                     }
-                    currentAccessibleForOverrides.addAll(accessibleForOverridesByClass.getOrDefault(interfaceModuleClass, emptySet()));
+                    currentInheritedAccess.addAll(inheritableAccessByClass.getOrDefault(interfaceModuleClass, emptySet()));
                 }
             }
             // only initialize local state AFTER visiting all dependencies above!
@@ -264,7 +264,7 @@ public void visit(int version, int access, String name, String signature, String
             this.isPublicClass = (access & ACC_PUBLIC) != 0;
             this.isFinalClass = (access & ACC_FINAL) != 0;
             this.isDeprecatedClass = (access & ACC_DEPRECATED) != 0;
-            this.accessibleForOverrides = currentAccessibleForOverrides;
+            this.inheritableAccess = currentInheritedAccess;
             this.accessibleImplementations = newSortedSet();
             this.deprecations = newSortedSet();
         }
@@ -289,7 +289,7 @@ private Set<String> getModuleExports(String module) {
         public void visitEnd() {
             super.visitEnd();
             if (accessibleImplementationsByClass.put(moduleClass, unmodifiableSet(accessibleImplementations)) != null
-                || accessibleForOverridesByClass.put(moduleClass, unmodifiableSet(accessibleForOverrides)) != null
+                || inheritableAccessByClass.put(moduleClass, unmodifiableSet(inheritableAccess)) != null
                 || deprecationsByClass.put(moduleClass, unmodifiableSet(deprecations)) != null) {
                 throw new IllegalStateException("Class " + moduleClass.clazz + " was already visited!");
             }
@@ -337,18 +337,21 @@ public final MethodVisitor visitMethod(int access, String name, String descripto
 
             var method = new AccessibleMethod(name, descriptor, isPublic, isFinal, isStatic);
             if (isPublicClass && isExported && EXCLUDES.contains(method) == false) {
-                // class is public and exported, for final classes skip non-public methods
+                // class is public and exported, to be accessible outside the JDK the method must be either:
+                // - public or
+                // - protected if not a final class
                 if (isPublic || isFinalClass == false) {
                     accessibleImplementations.add(method);
-                    // if not static, the method is accessible for overrides
-                    if (isStatic == false) {
-                        accessibleForOverrides.add(method);
+                    // if public and not static, the method can be accessible on non-public and non-exported subclasses,
+                    // but skip constructors
+                    if (isPublic && isStatic == false && name.equals("<init>") == false) {
+                        inheritableAccess.add(method);
                     }
                     if (isDeprecatedClass || isDeprecated) {
                         deprecations.add(method);
                     }
                 }
-            } else if (accessibleForOverrides.contains(method)) {
+            } else if (inheritableAccess.contains(method)) {
                 accessibleImplementations.add(method);
                 if (isDeprecatedClass || isDeprecated) {
                     deprecations.add(method);

server/src/main/java/org/elasticsearch/cluster/NotMasterException.java

@@ -34,6 +34,10 @@ public NotMasterException(StreamInput in) throws IOException {
         super(in);
     }
 
+    public NotMasterException(String msg, Throwable cause, Object... args) {
+        super(msg, cause, args);
+    }
+
     @Override
     public Throwable fillInStackTrace() {
         return this;

server/src/main/java/org/elasticsearch/cluster/service/MasterService.java

@@ -1283,7 +1283,7 @@ public String toString() {
                 if (lifecycle.started()) {
                     nextBatch.run(batchCompletionListener);
                 } else {
-                    nextBatch.onRejection(new FailedToCommitClusterStateException("node closed", getRejectionException()));
+                    nextBatch.onRejection(new NotMasterException("node closed", getRejectionException()));
                     batchCompletionListener.onResponse(null);
                 }
             });
@@ -1309,7 +1309,7 @@ private void onCompletion() {
         @Override
         public void onRejection(Exception e) {
             assert e instanceof EsRejectedExecutionException esre && esre.isExecutorShutdown() : e;
-            drainQueueOnRejection(new FailedToCommitClusterStateException("node closed", e));
+            drainQueueOnRejection(new NotMasterException("node closed", e));
         }
 
         @Override
@@ -1336,7 +1336,7 @@ private Batch takeNextBatch() {
     private void forkQueueProcessor() {
         // single-threaded: started when totalQueueSize transitions from 0 to 1 and keeps calling itself until the queue is drained.
         if (lifecycle.started() == false) {
-            drainQueueOnRejection(new FailedToCommitClusterStateException("node closed", getRejectionException()));
+            drainQueueOnRejection(new NotMasterException("node closed", getRejectionException()));
             return;
         }
 
@@ -1353,7 +1353,7 @@ private EsRejectedExecutionException getRejectionException() {
         return new EsRejectedExecutionException("master service is in state [" + lifecycleState() + "]", true);
     }
 
-    private void drainQueueOnRejection(FailedToCommitClusterStateException e) {
+    private void drainQueueOnRejection(NotMasterException e) {
         assert totalQueueSize.get() > 0;
         do {
             assert currentlyExecutingBatch == null;
@@ -1407,12 +1407,11 @@ private interface Batch {
         /**
          * Called when the batch is rejected due to the master service shutting down.
          *
-         * @param e is a {@link FailedToCommitClusterStateException} to cause things like {@link TransportMasterNodeAction} to retry after
+         * @param e is a {@link NotMasterException} to cause things like {@link TransportMasterNodeAction} to retry after
          *          submitting a task to a master which shut down. {@code e.getCause()} is the rejection exception, which should be a
          *          {@link EsRejectedExecutionException} with {@link EsRejectedExecutionException#isExecutorShutdown()} true.
          */
-        // Should really be a NodeClosedException instead, but this exception type doesn't trigger retries today.
-        void onRejection(FailedToCommitClusterStateException e);
+        void onRejection(NotMasterException e);
 
         /**
          * @return number of tasks in this batch if the batch is pending, or {@code 0} if the batch is not pending.
@@ -1634,7 +1633,7 @@ T acquireForExecution() {
                 return task;
             }
 
-            void onRejection(FailedToCommitClusterStateException e) {
+            void onRejection(NotMasterException e) {
                 final var task = acquireForExecution();
                 if (task != null) {
                     try (var ignored = storedContextSupplier.get()) {
@@ -1654,7 +1653,7 @@ boolean isPending() {
 
         private class Processor implements Batch {
             @Override
-            public void onRejection(FailedToCommitClusterStateException e) {
+            public void onRejection(NotMasterException e) {
                 final var items = queueSize.getAndSet(0);
                 for (int i = 0; i < items; i++) {
                     final var entry = queue.poll();

server/src/main/resources/transport/definitions/referable/esql_plan_with_no_columns.csv

@@ -0,0 +1 @@
+9186000

server/src/main/resources/transport/upper_bounds/9.3.csv

@@ -1 +1 @@
-initial_9.2.0,9185000
+esql_plan_with_no_columns,9186000