Bridge live cluster settings into UnifiedQueryContext for PPL_REX_MAX_MATCH_LIMIT

The previous commit defaulted `PPL_REX_MAX_MATCH_LIMIT=10` in
`UnifiedQueryContext.Builder.settings` to fix the NPE in
`AstBuilder.visitRexCommand` on the unified path. The default is correct, but
it doesn't respect mid-run cluster overrides — every key in the static map
returns its hardcoded value regardless of `_cluster/settings` updates. This
breaks `CalciteRexCommandIT.testRexMaxMatchConfigurableLimit`, which
explicitly sets the cluster-side limit to 5 and asserts that `max_match=0`
caps at 5; on the unified path it stayed at 10.

This change introduces a `Builder.liveSettings(Settings)` hook that the REST
handler can use to inject the cluster's live `OpenSearchSettings` instance.
At `build()` time the Builder snapshots the live value of
`PPL_REX_MAX_MATCH_LIMIT` (only — see scoping note below) into the static
map, overriding the hardcoded default when the operator has set a cluster
value. Snapshot-at-build matches the per-HTTP-request lifecycle of
`UnifiedQueryContext` and avoids per-call lookup overhead.

## Why scoped to PPL_REX_MAX_MATCH_LIMIT only

The same architectural gap exists for every key in the static map
(`QUERY_SIZE_LIMIT`, `PPL_SUBSEARCH_MAXOUT`, `PPL_JOIN_SUBSEARCH_MAXOUT`,
`CALCITE_ENGINE_ENABLED`). For three of those, the static defaults are fine
in practice (no test overrides them mid-run; `head N` covers `QUERY_SIZE_LIMIT`
per-query). `CALCITE_ENGINE_ENABLED` is intentionally pinned to `true` for
the unified path — a cluster override toggling it off would defeat the point
of routing here. So this PR widens only the one key that demonstrably needs
it; widening the snapshot to the rest is a future scope decision tied to
whichever new IT first depends on it.

## Wire-up

`RestUnifiedQueryAction` gains a `pluginSettings` field (the same
`OpenSearchSettings` instance bound in the Guice module) and forwards it to
the Builder in both `buildContext` (per-request execution path) and
`buildParsingContext` (analytics-routing index name probe). Both
construction sites — `SQLPlugin.createSqlAnalyticsRouter` and
`TransportPPLQueryAction.<init>` — are updated to pass the existing
plugin-side `Settings` instance.

`buildParsingContext` had been `static` because it didn't need any instance
state; it's now an instance method since it reads `pluginSettings`.

## Test results

CalciteRexCommandIT through the analytics-engine route (every PPL query
forced through `/_analytics/ppl` via `tests.analytics.force_routing=true`):

* Before this change: 17/18 — `testRexMaxMatchConfigurableLimit` fails with
  `expected:<5> but was:<10>` (cluster override doesn't reach the unified
  path).
* After this change: 18/18 — all `testRexMaxMatch*` variants honor the
  cluster setting.

## Companion PR

opensearch-project/OpenSearch#21550 — onboards PPL `rex` to DataFusion via
the analytics-engine path. The 17/18 baseline reported in that PR's
description was measured against the previous commit on this branch; with
this change the route hits 18/18.

Signed-off-by: Jialiang Liang <jiallian@amazon.com>

Author: RyanL1997

api/src/main/java/org/opensearch/sql/api/UnifiedQueryContext.java

@@ -113,6 +113,7 @@ public static class Builder {
     private String defaultNamespace;
     private boolean cacheMetadata = false;
     private boolean profiling = false;
+    private Settings liveSettings;
 
     /**
      * Setting values with defaults from SysLimit.DEFAULT. Only includes planning-required settings
@@ -215,6 +216,25 @@ public Builder setting(String name, Object value) {
       return this;
     }
 
+    /**
+     * Injects the live cluster {@link Settings} so dynamic cluster overrides reach the
+     * unified-path settings map. Without this, every key in {@link #settings} resolves to
+     * its hardcoded default and {@code _cluster/settings} updates are invisible to the
+     * unified path.
+     *
+     * <p>Scoped to {@link Settings.Key#PPL_REX_MAX_MATCH_LIMIT} for now — required so
+     * {@code rex max_match=0} caps at the operator-configured limit (CalciteRexCommandIT's
+     * testRexMaxMatchConfigurableLimit). The other keys in {@link #settings} keep their
+     * static defaults; widening the snapshot to all keys is a separate scope.
+     *
+     * @param liveSettings the cluster's live {@code OpenSearchSettings} instance
+     * @return this builder instance
+     */
+    public Builder liveSettings(Settings liveSettings) {
+      this.liveSettings = liveSettings;
+      return this;
+    }
+
     /**
      * Builds a {@link UnifiedQueryContext} with the configuration.
      *
@@ -223,6 +243,18 @@ public Builder setting(String name, Object value) {
     public UnifiedQueryContext build() {
       Objects.requireNonNull(queryType, "Must specify language before build");
 
+      // Snapshot PPL_REX_MAX_MATCH_LIMIT from live cluster settings if present so a
+      // mid-test `_cluster/settings` PUT takes effect on the unified path. Snapshot
+      // semantics (not per-call lookup) — UnifiedQueryContext is built per HTTP
+      // request, so a one-shot read at build() is sufficient. Other keys are
+      // intentionally not bridged here; that's a follow-up scope decision.
+      if (liveSettings != null) {
+        Object liveRexLimit = liveSettings.getSettingValue(PPL_REX_MAX_MATCH_LIMIT);
+        if (liveRexLimit != null) {
+          settings.put(PPL_REX_MAX_MATCH_LIMIT, liveRexLimit);
+        }
+      }
+
       Settings settings = buildSettings();
       CalcitePlanContext planContext =
           CalcitePlanContext.create(

plugin/src/main/java/org/opensearch/sql/plugin/SQLPlugin.java

@@ -208,7 +208,7 @@ private BiFunction<SQLQueryRequest, RestChannel, Boolean> createSqlAnalyticsRout
             if (executor == null) {
               return null;
             }
-            cached[0] = new RestUnifiedQueryAction(client, clusterService, executor);
+            cached[0] = new RestUnifiedQueryAction(client, clusterService, executor, pluginSettings);
           }
           return cached[0];
         };

plugin/src/main/java/org/opensearch/sql/plugin/rest/RestUnifiedQueryAction.java

@@ -59,14 +59,17 @@ public class RestUnifiedQueryAction {
   private final AnalyticsExecutionEngine analyticsEngine;
   private final NodeClient client;
   private final ClusterService clusterService;
+  private final org.opensearch.sql.common.setting.Settings pluginSettings;
 
   public RestUnifiedQueryAction(
       NodeClient client,
       ClusterService clusterService,
-      QueryPlanExecutor<RelNode, Iterable<Object[]>> planExecutor) {
+      QueryPlanExecutor<RelNode, Iterable<Object[]>> planExecutor,
+      org.opensearch.sql.common.setting.Settings pluginSettings) {
     this.client = client;
     this.clusterService = clusterService;
     this.analyticsEngine = new AnalyticsExecutionEngine(planExecutor);
+    this.pluginSettings = pluginSettings;
   }
 
   /**
@@ -154,13 +157,14 @@ public void explain(
    * Build a lightweight context for parsing only (index name extraction). Does not require cluster
    * state or catalog schema.
    */
-  private static UnifiedQueryContext buildParsingContext(QueryType queryType) {
-    return UnifiedQueryContext.builder().language(queryType).build();
+  private UnifiedQueryContext buildParsingContext(QueryType queryType) {
+    return UnifiedQueryContext.builder().language(queryType).liveSettings(pluginSettings).build();
   }
 
   private UnifiedQueryContext buildContext(QueryType queryType, boolean profiling) {
     return UnifiedQueryContext.builder()
         .language(queryType)
+        .liveSettings(pluginSettings)
         .catalog(SCHEMA_NAME, OpenSearchSchemaBuilder.buildSchema(clusterService.state()))
         .defaultNamespace(SCHEMA_NAME)
         .profiling(profiling)

plugin/src/main/java/org/opensearch/sql/plugin/transport/TransportPPLQueryAction.java

@@ -78,17 +78,18 @@ public TransportPPLQueryAction(
 
     ModulesBuilder modules = new ModulesBuilder();
     modules.add(new OpenSearchPluginModule());
+    org.opensearch.sql.common.setting.Settings pluginSettings =
+        new OpenSearchSettings(clusterService.getClusterSettings());
     modules.add(
         b -> {
           b.bind(NodeClient.class).toInstance(client);
-          b.bind(org.opensearch.sql.common.setting.Settings.class)
-              .toInstance(new OpenSearchSettings(clusterService.getClusterSettings()));
+          b.bind(org.opensearch.sql.common.setting.Settings.class).toInstance(pluginSettings);
           b.bind(DataSourceService.class).toInstance(dataSourceService);
         });
     this.injector = Guice.createInjector(modules);
     AnalyticsExecutorHolder.set(queryPlanExecutor);
     this.unifiedQueryHandler =
-        new RestUnifiedQueryAction(client, clusterService, queryPlanExecutor);
+        new RestUnifiedQueryAction(client, clusterService, queryPlanExecutor, pluginSettings);
     this.pplEnabled =
         () ->
             MULTI_ALLOW_EXPLICIT_INDEX.get(clusterSettings)