Add tests.analytics.parquet_indices test toggle

Adds a small, opt-in test infrastructure slice so the PPL integration
test suite can run end-to-end against the analytics-engine backend
without per-test rewiring.

`-Dtests.analytics.parquet_indices=true` makes `TestUtils.createIndexByRestClient`
back every test-created index with single-shard composite/parquet storage:

    index.pluggable.dataformat.enabled = true
    index.pluggable.dataformat = "composite"
    index.composite.primary_data_format = "parquet"

`RestUnifiedQueryAction.isAnalyticsIndex` (post-opensearch-project#5432) reads these settings
and routes any query against such indices to the analytics-engine planner
(DataFusion). No additional cluster setting or routing override required —
the production routing logic is the single source of truth.

Also adds `PPLIntegTestCase.isAnalyticsParquetIndicesEnabled()` as a
per-test predicate so individual tests can branch their assertions on
engine semantics (DataFusion follows different ordering and null-bucket
semantics than the legacy V2 and Calcite-DSL paths).

Bulk loads on parquet-backed indices use `refresh=true` because
`analytics-backend-lucene`'s `LuceneCommitter.getSafeCommitInfo` is a
`TODO:: with index deleter` stub that hangs `refresh=wait_for` until the
test framework request timeout (~60s).

`integ-test/build.gradle` forwards the property to `:integTestRemote` so
the gradle command line is the single knob.

Default behavior is unchanged — with the flag unset, every test-created
index is Lucene-backed and every IT runs through the existing V2 /
Calcite path exactly as before.

Signed-off-by: Kai Huang <ahkcs@amazon.com>

Author: ahkcs

integ-test/build.gradle

@@ -849,6 +849,14 @@ task integTestRemote(type: RestIntegTestTask) {
     systemProperty "user", System.getProperty("user")
     systemProperty "password", System.getProperty("password")
 
+    // Forward the analytics-engine parquet-indices toggle when set on the gradle command
+    // line. TestUtils.createIndexByRestClient reads this to back every test-created index
+    // with composite/parquet so RestUnifiedQueryAction.isAnalyticsIndex (post-#5432) routes
+    // to the analytics-engine planner via index settings.
+    if (System.getProperty("tests.analytics.parquet_indices") != null) {
+        systemProperty 'tests.analytics.parquet_indices', System.getProperty("tests.analytics.parquet_indices")
+    }
+
     // Set default query size limit
     systemProperty 'defaultQuerySizeLimit', '10000'
 

integ-test/src/test/java/org/opensearch/sql/legacy/TestUtils.java

@@ -37,6 +37,18 @@ public class TestUtils {
 
   private static final String MAPPING_FILE_PATH = "src/test/resources/indexDefinitions/";
 
+  /**
+   * System property that makes every test-created index parquet-backed (composite primary data
+   * format = parquet) with a single shard. When set, {@link
+   * RestUnifiedQueryAction#isAnalyticsIndex} (which routes based on {@code
+   * index.pluggable.dataformat.enabled} / {@code index.pluggable.dataformat=composite}, see #5432)
+   * will return {@code true} for every test-created index — exercising the analytics-engine route
+   * end-to-end without per-test rewiring.
+   *
+   * <p>Off by default; normal CI is untouched.
+   */
+  public static final String ANALYTICS_PARQUET_INDICES_PROP = "tests.analytics.parquet_indices";
+
   /**
    * Create test index by REST client.
    *
@@ -48,6 +60,9 @@ public static void createIndexByRestClient(RestClient client, String indexName,
     Request request = new Request("PUT", "/" + indexName);
     JSONObject jsonObject = isNullOrEmpty(mapping) ? new JSONObject() : new JSONObject(mapping);
     setZeroReplicas(jsonObject);
+    if (Boolean.parseBoolean(System.getProperty(ANALYTICS_PARQUET_INDICES_PROP, "false"))) {
+      makeParquetBacked(jsonObject);
+    }
     request.setJsonEntity(jsonObject.toString());
     performRequest(client, request);
   }
@@ -69,6 +84,25 @@ private static void setZeroReplicas(JSONObject jsonObject) {
     jsonObject.put("settings", settings);
   }
 
+  /**
+   * Switches the test index to a parquet-backed composite store with a single shard so the
+   * analytics-engine path has a backend that can scan it. Routing is then driven entirely by index
+   * settings (#5432) — no other test plumbing required.
+   */
+  private static void makeParquetBacked(JSONObject jsonObject) {
+    JSONObject settings =
+        jsonObject.has("settings") ? jsonObject.getJSONObject("settings") : new JSONObject();
+    JSONObject indexSettings =
+        settings.has("index") ? settings.getJSONObject("index") : new JSONObject();
+    indexSettings.put("number_of_shards", 1);
+    indexSettings.put("pluggable.dataformat.enabled", true);
+    indexSettings.put("pluggable.dataformat", "composite");
+    indexSettings.put("composite.primary_data_format", "parquet");
+    indexSettings.put("composite.secondary_data_formats", new org.json.JSONArray());
+    settings.put("index", indexSettings);
+    jsonObject.put("settings", settings);
+  }
+
   /**
    * https://github.com/elastic/elasticsearch/pull/49959<br>
    * Deprecate creation of dot-prefixed index names except for hidden and system indices. Create
@@ -116,8 +150,17 @@ public static boolean isIndexExist(RestClient client, String indexName) {
   public static void loadDataByRestClient(
       RestClient client, String indexName, String dataSetFilePath) throws IOException {
     Path path = Paths.get(getResourceFilePath(dataSetFilePath));
-    Request request =
-        new Request("POST", "/" + indexName + "/_bulk?refresh=wait_for&wait_for_active_shards=all");
+    // Workaround: parquet-backed indices in the analytics-backend-lucene composite engine
+    // do not yet implement LuceneCommitter.getSafeCommitInfo (UnsupportedOperationException
+    // "TODO:: with index deleter"), which hangs refresh=wait_for until the test framework
+    // request timeout (~60s). Force-refresh sidesteps the safe-commit-info path while still
+    // making the bulk-loaded docs immediately searchable. Drop this branch once
+    // LuceneCommitter.getSafeCommitInfo is implemented.
+    String refreshParam =
+        Boolean.parseBoolean(System.getProperty(ANALYTICS_PARQUET_INDICES_PROP, "false"))
+            ? "refresh=true"
+            : "refresh=wait_for&wait_for_active_shards=all";
+    Request request = new Request("POST", "/" + indexName + "/_bulk?" + refreshParam);
     request.setJsonEntity(new String(Files.readAllBytes(path)));
     performRequest(client, request);
   }

integ-test/src/test/java/org/opensearch/sql/ppl/PPLIntegTestCase.java

@@ -30,6 +30,7 @@
 import org.opensearch.sql.common.setting.Settings;
 import org.opensearch.sql.common.setting.Settings.Key;
 import org.opensearch.sql.legacy.SQLIntegTestCase;
+import org.opensearch.sql.legacy.TestUtils;
 import org.opensearch.sql.protocol.response.format.Format;
 import org.opensearch.sql.util.RetryProcessor;
 
@@ -49,6 +50,20 @@ protected void init() throws Exception {
     disableCalcite(); // calcite is enabled by default from 3.3.0
   }
 
+  /**
+   * Returns {@code true} when the suite was started with {@code
+   * -Dtests.analytics.parquet_indices=true}. Use this to branch test assertions that depend on the
+   * execution backend — when this flag is on, every test-created index is composite/parquet, which
+   * makes {@code RestUnifiedQueryAction.isAnalyticsIndex} (post-#5432) route every query to the
+   * analytics-engine backend (DataFusion) instead of the Calcite enumerable / DSL-pushdown backend.
+   * DataFusion follows different ordering and null-bucket semantics than the legacy V2 and
+   * Calcite-DSL paths.
+   */
+  public static boolean isAnalyticsParquetIndicesEnabled() {
+    return Boolean.parseBoolean(
+        System.getProperty(TestUtils.ANALYTICS_PARQUET_INDICES_PROP, "false"));
+  }
+
   protected JSONObject executeQuery(String query) throws IOException {
     return jsonify(executeQueryToString(query));
   }