Bridge cluster overrides for PPL_REX_MAX_MATCH_LIMIT via the existing setting() API

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 sets the
cluster-side limit to 5 and asserts `max_match=0` caps at 5; on the unified
path it stayed at 10.

Rather than introducing a new `Settings`-typed Builder API, the REST handler
reads the live cluster value itself and routes it through the existing
`Builder.setting(String, Object)` method — keeping `UnifiedQueryContext`
decoupled from any specific `Settings` implementation:

  RestUnifiedQueryAction.applyClusterOverrides(builder)
    └── pluginSettings.getSettingValue(PPL_REX_MAX_MATCH_LIMIT)
          └── builder.setting("plugins.ppl.rex.max_match.limit", value)

`RestUnifiedQueryAction` gains a `pluginSettings` field (the same
`OpenSearchSettings` instance bound in the Guice module). Both
construction sites — `SQLPlugin.createSqlAnalyticsRouter` and
`TransportPPLQueryAction.<init>` — pass it through.

`RestUnifiedQueryActionTest` updated to pass a `mock(Settings.class)` for the
new constructor parameter.

## Why scoped to PPL_REX_MAX_MATCH_LIMIT only

The same architectural gap exists for every key in the static defaults 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. 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.

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

Author: RyanL1997

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

@@ -131,10 +131,12 @@ public static class Builder {
      *
      * <p>{@link Settings.Key#PPL_REX_MAX_MATCH_LIMIT} defaults to {@code 10} here because {@code
      * AstBuilder.visitRexCommand} reads it unconditionally and unboxes to {@code int} — a {@code
-     * null} return from {@code getSettingValue} NPEs the planner before any operator- level
+     * null} return from {@code getSettingValue} NPEs the planner before any operator-level
      * capability check runs. The value mirrors the cluster-side default of {@code 10} registered by
-     * {@code OpenSearchSettings.PPL_REX_MAX_MATCH_LIMIT_SETTING}, so unified-path behavior matches
-     * v2-path behavior when neither has an explicit cluster override.
+     * {@code OpenSearchSettings.PPL_REX_MAX_MATCH_LIMIT_SETTING}. Cluster-side overrides reach this
+     * map via {@link #setting(String, Object)} — the REST handler reads the live value from {@code
+     * OpenSearchSettings} and routes it through that existing API, keeping {@link
+     * UnifiedQueryContext} decoupled from any specific {@link Settings} implementation.
      */
     private final Map<Settings.Key, Object> settings =
         new HashMap<Settings.Key, Object>(
@@ -232,6 +234,7 @@ public UnifiedQueryContext build() {
             case SQL -> UnifiedSqlSpec.extended();
             case PPL -> UnifiedPplSpec.create();
           };
+
       Settings settings = buildSettings();
       CalcitePlanContext planContext =
           CalcitePlanContext.create(

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

@@ -208,7 +208,8 @@ 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,19 +157,42 @@ 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 applyClusterOverrides(UnifiedQueryContext.builder().language(queryType)).build();
   }
 
   private UnifiedQueryContext buildContext(QueryType queryType, boolean profiling) {
-    return UnifiedQueryContext.builder()
-        .language(queryType)
-        .catalog(SCHEMA_NAME, OpenSearchSchemaBuilder.buildSchema(clusterService.state()))
-        .defaultNamespace(SCHEMA_NAME)
-        .profiling(profiling)
+    return applyClusterOverrides(
+            UnifiedQueryContext.builder()
+                .language(queryType)
+                .catalog(SCHEMA_NAME, OpenSearchSchemaBuilder.buildSchema(clusterService.state()))
+                .defaultNamespace(SCHEMA_NAME)
+                .profiling(profiling))
         .build();
   }
 
+  /**
+   * Routes operator-configured cluster overrides into the builder via the existing {@code
+   * setting(String, Object)} API, keeping {@link UnifiedQueryContext} decoupled from any specific
+   * {@link org.opensearch.sql.common.setting.Settings} implementation.
+   *
+   * <p>Currently scoped to {@code plugins.ppl.rex.max_match.limit} — required so the unified path
+   * honors {@code _cluster/settings} updates for {@code rex max_match} (CalciteRexCommandIT's
+   * testRexMaxMatchConfigurableLimit). Add keys here if a future PR / IT depends on cluster-side
+   * fidelity for one of the other planning settings.
+   */
+  private UnifiedQueryContext.Builder applyClusterOverrides(UnifiedQueryContext.Builder builder) {
+    Object rexLimit =
+        pluginSettings.getSettingValue(
+            org.opensearch.sql.common.setting.Settings.Key.PPL_REX_MAX_MATCH_LIMIT);
+    if (rexLimit != null) {
+      builder.setting(
+          org.opensearch.sql.common.setting.Settings.Key.PPL_REX_MAX_MATCH_LIMIT.getKeyValue(),
+          rexLimit);
+    }
+    return builder;
+  }
+
   /**
    * Extract the source index name by parsing the query and visiting the AST to find the Relation
    * node. Uses the context's parser which supports both PPL and SQL.

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

@@ -67,6 +67,7 @@ public class TransportPPLQueryAction
 
   private final NodeClient clientRef;
   private final ClusterService clusterServiceRef;
+  private final org.opensearch.sql.common.setting.Settings pluginSettingsRef;
 
   @Inject
   public TransportPPLQueryAction(
@@ -82,11 +83,13 @@ public TransportPPLQueryAction(
 
     ModulesBuilder modules = new ModulesBuilder();
     modules.add(new OpenSearchPluginModule());
+    org.opensearch.sql.common.setting.Settings pluginSettings =
+        new OpenSearchSettings(clusterService.getClusterSettings());
+    this.pluginSettingsRef = pluginSettings;
     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);
@@ -105,7 +108,8 @@ public void setQueryPlanExecutor(
       QueryPlanExecutor<RelNode, Iterable<Object[]>> queryPlanExecutor) {
     AnalyticsExecutorHolder.set(queryPlanExecutor);
     this.unifiedQueryHandler =
-        new RestUnifiedQueryAction(clientRef, clusterServiceRef, queryPlanExecutor);
+        new RestUnifiedQueryAction(
+            clientRef, clusterServiceRef, queryPlanExecutor, pluginSettingsRef);
   }
 
   /**

plugin/src/test/java/org/opensearch/sql/plugin/rest/RestUnifiedQueryActionTest.java

@@ -14,6 +14,7 @@
 import org.junit.Test;
 import org.opensearch.analytics.exec.QueryPlanExecutor;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.sql.common.setting.Settings;
 import org.opensearch.sql.executor.QueryType;
 import org.opensearch.transport.client.node.NodeClient;
 
@@ -30,7 +31,8 @@ public void setUp() {
     @SuppressWarnings("unchecked")
     QueryPlanExecutor<RelNode, Iterable<Object[]>> executor = mock(QueryPlanExecutor.class);
     action =
-        new RestUnifiedQueryAction(mock(NodeClient.class), mock(ClusterService.class), executor);
+        new RestUnifiedQueryAction(
+            mock(NodeClient.class), mock(ClusterService.class), executor, mock(Settings.class));
   }
 
   @Test