spath: Arrow Map response marshalling + parquet-backed test indices

Two complementary changes for closing PPL `spath` parity on the
analytics-engine route. Pairs with opensearch-project/OpenSearch#21664
(the analytics-engine `json_extract_all` UDF + ITEM-on-MAP dispatch +
MAP capability registrations). Both PRs together take
`CalcitePPLSpathCommandIT` on the analytics-engine route from 0 / 16
to 16 / 16 without regressing the v2 / Calcite path (still 16 / 16).

## Pass rate

| IT | Route | Before | After |
|---|---|---|---|
| `CalcitePPLSpathCommandIT` | analytics-engine (`-Dtests.analytics.force_routing=true -Dtests.analytics.parquet_indices=true`) | 0 / 16 | **16 / 16** |
| `CalcitePPLSpathCommandIT` | default v2 / Calcite (no flags) | 16 / 16 | 16 / 16 (no regression) |

The analytics-route number depends on this PR + #21664 landing together;
neither PR alone moves it off 0 / 16.

## Changes

1. **`core/.../ExprValueUtils.java`** — two boundary fixes for Arrow Map
   values that arrive from the analytics-engine response stream:
   - `fromObjectValue` gains a FQN-keyed branch for
     `org.apache.arrow.vector.util.Text` (decoded via `toString()`).
     Arrow's MapVector / StructVector emit values as `Text` (a UTF-8
     byte-buffer wrapper that does NOT implement `CharSequence`), which
     none of the typed `instanceof` branches recognized. Without this,
     any UDF returning `Map<Utf8, Utf8>` through the analytics-engine
     route surfaces as `ExpressionEvaluationException: unsupported
     object class org.apache.arrow.vector.util.Text`. FQN match keeps
     `core/` free of an Arrow dependency.
   - `tupleValue` widens its parameter type to `Map<?, Object>` and
     normalizes keys via `String.valueOf` so the downstream
     `LinkedHashMap<String, ExprValue>` isn't polluted with non-String
     keys (the JDBC response formatter then sees stable String keys).

2. **`integ-test/.../CalcitePPLSpathCommandIT.java`** — refactor
   `init()` to use `TestUtils.createIndexByRestClient` with an explicit
   keyword mapping for each of the four test indices (`test_spath`,
   `test_spath_auto`, `test_spath_cmd`, `test_spath_null`) before the
   per-doc PUTs. Without an explicit createIndex, the dynamic-mapping
   route bypasses the `tests.analytics.parquet_indices=true` parquet
   injection (because the toggle only fires inside
   `TestUtils.createIndexByRestClient`) and the analytics-engine
   fragment driver then fails with `UnsupportedOperationException:
   acquireReader is not supported in EngineBackedIndexer` for any test
   that reaches the runtime — `testSimpleSpath` was the only test
   affected before this PR (the other 15 failed earlier at the planner
   capability check). Idempotency via `TestUtils.isIndexExist` so the
   cluster-reuse pattern between `@Test` methods keeps working. No
   change for the v2 / Calcite path (the helper is a no-op for
   non-parquet runs).

3. **`docs/dev/spath-command-analytics-route-status.md`** — new
   companion to `docs/dev/ppl-analytics-engine-routing.md` documenting
   the full spath workstream: per-test baseline, bucket
   classification, the two repos' changes side-by-side, the design
   decisions (Map return type vs. stringified JSON, ITEM-on-MAP
   dispatch, FieldType.MAP capability registration), and the
   reproduction instructions.

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

Author: ahkcs

core/src/main/java/org/opensearch/sql/data/model/ExprValueUtils.java

@@ -111,6 +111,17 @@ public static ExprValue nullValue() {
     return ExprNullValue.of();
   }
 
+  private static final String ARROW_TEXT_CLASS_NAME = "org.apache.arrow.vector.util.Text";
+
+  /**
+   * Whether {@code o} is an Arrow {@code Text} (the UTF-8 byte-buffer wrapper that arrow's Map /
+   * Struct / List vectors emit for string values). FQN match keeps {@code core/} free of an Arrow
+   * dependency.
+   */
+  private static boolean isArrowText(Object o) {
+    return o != null && ARROW_TEXT_CLASS_NAME.equals(o.getClass().getName());
+  }
+
   /** Construct ExprValue from Object. */
   public static ExprValue fromObjectValue(Object o) {
     if (null == o) {
@@ -143,6 +154,18 @@ public static ExprValue fromObjectValue(Object o) {
       return new ExprDoubleValue(d);
     } else if (o instanceof String) {
       return stringValue((String) o);
+    } else if (isArrowText(o)) {
+      // Arrow MapVector / StructVector yields values as
+      // `org.apache.arrow.vector.util.Text` — a UTF-8 byte-buffer wrapper that
+      // does NOT implement CharSequence and therefore wouldn't match any of the
+      // typed branches above. `Text.toString()` decodes to a real Java String.
+      // Matched by FQN rather than instanceof so `core/` doesn't acquire an
+      // Arrow dependency for one type-system bridge. Without this branch the
+      // analytics-engine route surfaces `ExpressionEvaluationException:
+      // unsupported object class org.apache.arrow.vector.util.Text` from any
+      // UDF returning Map<Utf8, Utf8> (first such UDF is `json_extract_all`
+      // powering PPL `spath`).
+      return stringValue(o.toString());
     } else if (o instanceof Float f) {
       if (!Float.isFinite(f)) {
         return LITERAL_NULL;

docs/dev/spath-command-analytics-route-status.md

@@ -0,0 +1,164 @@
+# `spath` command on the analytics-engine route — current status
+
+Snapshot of `CalcitePPLSpathCommandIT` against the analytics-engine path
+(`-Dtests.analytics.force_routing=true -Dtests.analytics.parquet_indices=true`
+on `:integ-test:integTestRemote`), as of 2026-05-14.
+
+## Pass / fail summary
+
+| IT | Run | Pass | Fail | Notes |
+|---|---|---|---|---|
+| `CalcitePPLSpathCommandIT` | Baseline (upstream/main + coverage-bundle toggles) | 0 / 16 | 16 | 15 rejected at plan time on `JSON_EXTRACT_ALL` capability gap; 1 (`testSimpleSpath`) hit `EngineBackedIndexer.acquireReader` because PUT-created indices weren't parquet-backed |
+| `CalcitePPLSpathCommandIT` | After IT-infra refactor only | 1 / 16 | 15 | `testSimpleSpath` passes (uses `JSON_EXTRACT`, already in `STANDARD_PROJECT_OPS`); remaining 15 still on `JSON_EXTRACT_ALL` |
+| `CalcitePPLSpathCommandIT` | After Rust UDF + Java wiring | 10 / 16 | 6 | Auto-extract variants pass; 5 ITEM tests blocked on `map_extract` substrait + CHAR(N) key coercion; 1 WHERE test on `Unrecognized field type [MAP]` |
+| `CalcitePPLSpathCommandIT` | After ITEM/map_extract/CHAR→VARCHAR coercion + FieldType.MAP + filter capability | **16 / 16** | 0 | Full parity. v2/Calcite default path also 16/16 — no regression. |
+
+Reproduce:
+
+```bash
+./gradlew :integ-test:integTestRemote \
+  -Dtests.rest.cluster=localhost:9200 \
+  -Dtests.cluster=localhost:9300 \
+  -Dtests.clustername=runTask \
+  -Dtests.analytics.force_routing=true \
+  -Dtests.analytics.parquet_indices=true \
+  --tests "org.opensearch.sql.calcite.remote.CalcitePPLSpathCommandIT"
+```
+
+## Bucket
+
+**Mixed Bucket 3 / M (Rust UDF) and Bucket 1 / S0 (capability registration), plus
+a small SQL-plugin-side IT-infrastructure fix.** Closing `spath` parity touches
+both halves of the stack — Layer 2 (capability registry) and Layer 3 (DataFusion
+runtime) — because `JSON_EXTRACT_ALL` is a PPL-internal UDF with no native
+DataFusion equivalent. The fix is shaped like a one-time investment that
+unblocks every future map-returning PPL function (the `LinkedHashMap<String, V>`
+pattern in `core/.../jsonUDF/`).
+
+## What landed
+
+The diff spans two repos:
+
+### `opensearch-project/OpenSearch` — analytics-engine side
+
+| File | Purpose |
+|---|---|
+| `sandbox/plugins/analytics-backend-datafusion/rust/src/udf/json_extract_all.rs` *(new, ~550 lines)* | Rust UDF returning `Map<Utf8, Utf8>`; mirrors `JsonExtractAllFunctionImpl` semantics (dot-path flatten, `{}` array marker, `[a, b, c]` merge format, `"null"` literal, malformed → empty map, top-level scalar → NULL). 16 unit tests. |
+| `sandbox/plugins/analytics-backend-datafusion/rust/src/udf/mod.rs` | Register `json_extract_all` in `register_all()` + module-info log message. |
+| `sandbox/plugins/analytics-backend-datafusion/src/main/resources/opensearch_scalar_functions.yaml` | Substrait extension entries for `json_extract_all(string) -> any1` and `map_extract(map<any1, any2>, any1) -> list<any2>`. |
+| `sandbox/libs/analytics-framework/.../ScalarFunction.java` | Add `JSON_EXTRACT_ALL(Category.SCALAR, SqlKind.OTHER_FUNCTION)` enum constant. |
+| `sandbox/libs/analytics-framework/.../FieldType.java` | Add `MAP("map")` enum constant and `case MAP -> FieldType.MAP` in `fromSqlTypeName`. |
+| `sandbox/plugins/analytics-backend-datafusion/.../JsonFunctionAdapters.java` | Add `JsonExtractAllAdapter` declaring `LOCAL_JSON_EXTRACT_ALL_OP` SqlFunction (return-type placeholder — `AbstractNameMappingAdapter#adapt` preserves the original PPL call's MAP RelDataType). |
+| `sandbox/plugins/analytics-backend-datafusion/.../ArrayElementAdapter.java` | Add `LOCAL_MAP_EXTRACT_OP` and a MAP-input branch in `adapt`: route `ITEM(map, key)` to `array_element(map_extract(map, CAST(key AS VARCHAR)), 1)`. The `array_element(…, 1)` wrap projects DataFusion's `List<value>` return down to a scalar; the CHAR→VARCHAR cast satisfies the substrait `any1` type-variable unification rule. |
+| `sandbox/plugins/analytics-backend-datafusion/.../DataFusionFragmentConvertor.java` | Register `json_extract_all` and `map_extract` in `ADDITIONAL_SCALAR_SIGS` so isthmus emits the right function reference. |
+| `sandbox/plugins/analytics-backend-datafusion/.../DataFusionAnalyticsBackendPlugin.java` | New `MAP_RETURNING_PROJECT_OPS` set (mirrors `ARRAY_RETURNING_PROJECT_OPS`) registered with `FieldType.MAP`. Register every operator in `STANDARD_FILTER_OPS` against `FieldType.MAP` so `where doc.user.name = 'John'` (which references the MAP column through ITEM) survives the filter-rule's field-index-keyed viability check. Adapter binding `JSON_EXTRACT_ALL → JsonExtractAllAdapter`. |
+| `sandbox/plugins/analytics-engine/.../ArrowValues.java` | Detect Arrow `MapVector` ahead of the ListVector branch and reassemble entries into a `LinkedHashMap<String, Object>` (Text→String normalization on both keys and values). Without this, the SQL plugin's response marshaller saw the raw Arrow Map layout (a `List<Map{keys, values}>` of entry structs) and rejected the values as `unsupported object class org.apache.arrow.vector.util.Text`. |
+| `gradle/run.gradle` | `arrow-flight-rpc` plugin block now also sets `opensearch.experimental.feature.transport.stream.enabled=true` so the analytics-engine + SQL-plugin co-install boots without the duplicate-handler Guice failure. |
+
+### `opensearch-project/sql` — SQL plugin side
+
+| File | Purpose |
+|---|---|
+| `core/.../data/model/ExprValueUtils.java` | (a) `tupleValue` widens its parameter type to `Map<?, Object>` so keys are normalized to strings regardless of the underlying Arrow `Text` type; (b) `fromObjectValue` gains a FQN-keyed branch for `org.apache.arrow.vector.util.Text` (string-decoded via `toString()`) so the response marshaller doesn't reject Arrow Map values. The FQN match keeps `core/` free of an Arrow dependency. |
+| `integ-test/.../calcite/remote/CalcitePPLSpathCommandIT.java` | Refactor `init()` to call `TestUtils.createIndexByRestClient` with an explicit `keyword` mapping for each of the four test indices (`test_spath`, `test_spath_auto`, `test_spath_cmd`, `test_spath_null`). Without explicit createIndex, the dynamic-mapping route bypassed `tests.analytics.parquet_indices=true`'s parquet-injection and `EngineBackedIndexer.acquireReader` failed at runtime. Idempotency via `TestUtils.isIndexExist` so the cluster-reuse pattern between `@Test` methods keeps working. |
+
+## Knock-on coverage
+
+The Rust UDF + capability registration work is reusable across the entire PPL
+map-returning function family. The same pattern (MAP_RETURNING_PROJECT_OPS,
+ITEM-on-Map dispatch via map_extract+array_element, MAP filter capability) now
+exists in the codebase, so a future PPL command that emits a `Map<VARCHAR, V>`
+column (e.g. `mapfrom` if ever lowered to a Calcite MAP RelDataType) is a
+one-line registration on top.
+
+The `ArrowValues.MapVector` branch and the `ExprValueUtils.Text` branch are
+also generic — they unlock any future UDF returning `Map<Utf8, Utf8>` through
+the analytics-engine route without further SQL-plugin work.
+
+## What was tricky
+
+- **Field-name alignment between Rust MapBuilder and Arrow Java's MapVector.**
+  Arrow's Java `MapVector.KEY_NAME` / `VALUE_NAME` are `"key"` / `"value"`
+  (singular). My initial Rust code used `"keys"` / `"values"` (plural), which
+  serialized fine through the wire but turned `MapVector.getObject(i)` into a
+  generic `JsonStringArrayList` of `Map<String, Object>` entries instead of a
+  proper key-value map. Aligning the Rust `MapFieldNames` to singular fixed
+  the round-trip.
+- **`map_extract` returns a list.** DataFusion's `map_extract(map, key)` returns
+  `List<value>` because map semantics permit duplicate keys. PPL's
+  `result.user.name` syntax assumes a scalar, so the ITEM adapter has to wrap
+  the `map_extract` call in `array_element(…, 1)` to project the list down to
+  a scalar.
+- **CHAR(N) literals don't unify with `any1` substrait type variables.** When
+  the YAML signature uses `map<any1, any2>, any1` for the key-typed slot, a
+  Calcite-emitted `'a.b'` CHAR(3) literal doesn't satisfy the type-variable
+  binding. The adapter has to insert an explicit `CAST(key AS VARCHAR)`
+  before the `map_extract` call.
+- **`MAP` had to be added to `FieldType` before `OpenSearchFilterRule` would
+  even reach the EQUALS lookup.** Once added, `EQUALS on FieldType.MAP` still
+  needed its own capability registration — the filter rule keys on the
+  field's declared type, not the predicate's actual operand types, so without
+  the explicit MAP entry the registry returned no viable backends.
+- **Two competing `:run` invocations stomp on the same data dir.** Repeated
+  restart attempts during debugging accumulated multiple OpenSearch JVMs all
+  pointing at `build/testclusters/runTask-0/data/...`, producing
+  `Failed to initialize Parquet writer: No such file or directory` errors
+  even though the data was being written. Killing all gradle wrappers + JVMs
+  and starting one clean cluster cleared it. (Future task-runners should
+  guard against this — gradle's testCluster bind to the same data dir
+  regardless of which gradle wrapper started it.)
+
+## Reproduction artefacts
+
+Worktree:
+`/Users/ahkcs/IdeaProjects/sql/.claude/worktrees/spath-analytics-route`
+(branch `feature/spath-analytics-route`, based off
+`feature/ppl-coverage-bundle`).
+
+Run output (analytics-engine route):
+`integ-test/build/test-results/integTestRemote/TEST-org.opensearch.sql.calcite.remote.CalcitePPLSpathCommandIT.xml`
+
+Cluster log:
+`OpenSearch/build/testclusters/runTask-0/logs/runTask.log`
+
+## Files to read once before sending the PR
+
+The analytics-engine side is the bulk of the change. Open these in order to
+review the boundary contracts:
+
+- `OpenSearch/sandbox/plugins/analytics-backend-datafusion/rust/src/udf/json_extract_all.rs`
+- `OpenSearch/sandbox/plugins/analytics-backend-datafusion/src/main/resources/opensearch_scalar_functions.yaml` (the `map_extract` and `json_extract_all` entries)
+- `OpenSearch/sandbox/plugins/analytics-backend-datafusion/src/main/java/org/opensearch/be/datafusion/ArrayElementAdapter.java` (the MAP branch and CAST)
+- `OpenSearch/sandbox/plugins/analytics-backend-datafusion/src/main/java/org/opensearch/be/datafusion/DataFusionAnalyticsBackendPlugin.java` (the `MAP_RETURNING_PROJECT_OPS` set and the MAP filter capability registration)
+- `OpenSearch/sandbox/plugins/analytics-engine/src/main/java/org/opensearch/analytics/exec/ArrowValues.java` (MapVector flattening)
+- `sql/core/src/main/java/org/opensearch/sql/data/model/ExprValueUtils.java` (Arrow Text marshaller)
+- `sql/integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLSpathCommandIT.java` (parquet-backed index init)
+
+## PR shape
+
+For `opensearch-project/OpenSearch`, the natural commit-order is:
+
+1. Add `FieldType.MAP` + `ScalarFunction.JSON_EXTRACT_ALL` enum constants
+   (framework SPI, no behavior change on its own).
+2. Add the `json_extract_all` Rust UDF (drop-in, isolated module).
+3. Register the Rust UDF in `udf/mod.rs` and the substrait extension YAML.
+4. Wire `JsonExtractAllAdapter` + `MAP_RETURNING_PROJECT_OPS` +
+   `STANDARD_FILTER_OPS×FieldType.MAP` in the backend plugin.
+5. Add the `map_extract`/`array_element` ITEM-on-MAP dispatch in
+   `ArrayElementAdapter` + YAML entry.
+6. `ArrowValues.MapVector` flattening.
+7. `gradle/run.gradle` — `transport.stream.enabled` flag.
+
+For `opensearch-project/sql`, a single PR:
+
+- `ExprValueUtils` — Arrow Text marshaller branch.
+- `CalcitePPLSpathCommandIT` — parquet-backed test indices.
+
+## Reference fixture
+
+The reference PR shape for a similar map-returning-function workstream
+mirrors this status doc. The fillnull worked example
+([`opensearch-project/OpenSearch#21472`](https://github.com/opensearch-project/OpenSearch/pull/21472))
+is a strict Bucket-1 / S0 (one-line capability addition); spath is a
+mixed bucket that closes the missing infrastructure for any future
+map-returning PPL function at once.

integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalcitePPLSpathCommandIT.java

@@ -15,9 +15,29 @@
 import org.json.JSONObject;
 import org.junit.jupiter.api.Test;
 import org.opensearch.client.Request;
+import org.opensearch.sql.legacy.TestUtils;
 import org.opensearch.sql.ppl.PPLIntegTestCase;
 
 public class CalcitePPLSpathCommandIT extends PPLIntegTestCase {
+  // Pin the doc fields as keyword so the analytics-engine compatibility run
+  // (tests.analytics.parquet_indices=true) provisions each test index as a
+  // parquet-backed composite store with parquet-friendly types. Without an
+  // explicit createIndex, the dynamic-mapping route auto-creates Lucene-only
+  // indices that DataFusion cannot acquireReader on, so the analytics-engine
+  // fragment driver fails with `UnsupportedOperationException: acquireReader
+  // is not supported in EngineBackedIndexer` before any spath function fires.
+  private static final String SIMPLE_DOC_MAPPING =
+      "{\"mappings\":{\"properties\":{\"doc\":{\"type\":\"keyword\"}}}}";
+
+  private static final String AUTO_DOC_MAPPING =
+      "{\"mappings\":{\"properties\":{"
+          + "\"nested_doc\":{\"type\":\"keyword\"},"
+          + "\"array_doc\":{\"type\":\"keyword\"},"
+          + "\"merge_doc\":{\"type\":\"keyword\"},"
+          + "\"stringify_doc\":{\"type\":\"keyword\"},"
+          + "\"empty_doc\":{\"type\":\"keyword\"},"
+          + "\"malformed_doc\":{\"type\":\"keyword\"}}}}";
+
   @Override
   public void init() throws Exception {
     super.init();
@@ -26,48 +46,64 @@ public void init() throws Exception {
     loadIndex(Index.BANK);
 
     // Simple JSON docs for path-based extraction
-    Request request1 = new Request("PUT", "/test_spath/_doc/1?refresh=true");
-    request1.setJsonEntity("{\"doc\": \"{\\\"n\\\": 1}\"}");
-    client().performRequest(request1);
+    if (!TestUtils.isIndexExist(client(), "test_spath")) {
+      TestUtils.createIndexByRestClient(client(), "test_spath", SIMPLE_DOC_MAPPING);
+
+      Request request1 = new Request("PUT", "/test_spath/_doc/1?refresh=true");
+      request1.setJsonEntity("{\"doc\": \"{\\\"n\\\": 1}\"}");
+      client().performRequest(request1);
 
-    Request request2 = new Request("PUT", "/test_spath/_doc/2?refresh=true");
-    request2.setJsonEntity("{\"doc\": \"{\\\"n\\\": 2}\"}");
-    client().performRequest(request2);
+      Request request2 = new Request("PUT", "/test_spath/_doc/2?refresh=true");
+      request2.setJsonEntity("{\"doc\": \"{\\\"n\\\": 2}\"}");
+      client().performRequest(request2);
 
-    Request request3 = new Request("PUT", "/test_spath/_doc/3?refresh=true");
-    request3.setJsonEntity("{\"doc\": \"{\\\"n\\\": 3}\"}");
-    client().performRequest(request3);
+      Request request3 = new Request("PUT", "/test_spath/_doc/3?refresh=true");
+      request3.setJsonEntity("{\"doc\": \"{\\\"n\\\": 3}\"}");
+      client().performRequest(request3);
+    }
 
     // Auto-extract mode: flatten rules and edge cases (empty, malformed)
-    Request autoExtractDoc = new Request("PUT", "/test_spath_auto/_doc/1?refresh=true");
-    autoExtractDoc.setJsonEntity(
-        "{\"nested_doc\": \"{\\\"user\\\":{\\\"name\\\":\\\"John\\\"}}\","
-            + " \"array_doc\": \"{\\\"tags\\\":[\\\"java\\\",\\\"sql\\\"]}\","
-            + " \"merge_doc\": \"{\\\"a\\\":{\\\"b\\\":1},\\\"a.b\\\":2}\","
-            + " \"stringify_doc\": \"{\\\"n\\\":30,\\\"b\\\":true,\\\"x\\\":null}\","
-            + " \"empty_doc\": \"{}\","
-            + " \"malformed_doc\": \"{\\\"user\\\":{\\\"name\\\":\"}");
-    client().performRequest(autoExtractDoc);
+    if (!TestUtils.isIndexExist(client(), "test_spath_auto")) {
+      TestUtils.createIndexByRestClient(client(), "test_spath_auto", AUTO_DOC_MAPPING);
+
+      Request autoExtractDoc = new Request("PUT", "/test_spath_auto/_doc/1?refresh=true");
+      autoExtractDoc.setJsonEntity(
+          "{\"nested_doc\": \"{\\\"user\\\":{\\\"name\\\":\\\"John\\\"}}\","
+              + " \"array_doc\": \"{\\\"tags\\\":[\\\"java\\\",\\\"sql\\\"]}\","
+              + " \"merge_doc\": \"{\\\"a\\\":{\\\"b\\\":1},\\\"a.b\\\":2}\","
+              + " \"stringify_doc\": \"{\\\"n\\\":30,\\\"b\\\":true,\\\"x\\\":null}\","
+              + " \"empty_doc\": \"{}\","
+              + " \"malformed_doc\": \"{\\\"user\\\":{\\\"name\\\":\"}");
+      client().performRequest(autoExtractDoc);
+    }
 
     // Auto-extract mode: 2-doc index for spath + command (eval/where/stats/sort) tests
-    Request cmdDoc1 = new Request("PUT", "/test_spath_cmd/_doc/1?refresh=true");
-    cmdDoc1.setJsonEntity(
-        "{\"doc\": \"{\\\"user\\\":{\\\"name\\\":\\\"John\\\",\\\"age\\\":30}}\"}");
-    client().performRequest(cmdDoc1);
+    if (!TestUtils.isIndexExist(client(), "test_spath_cmd")) {
+      TestUtils.createIndexByRestClient(client(), "test_spath_cmd", SIMPLE_DOC_MAPPING);
 
-    Request cmdDoc2 = new Request("PUT", "/test_spath_cmd/_doc/2?refresh=true");
-    cmdDoc2.setJsonEntity(
-        "{\"doc\": \"{\\\"user\\\":{\\\"name\\\":\\\"Alice\\\",\\\"age\\\":25}}\"}");
-    client().performRequest(cmdDoc2);
+      Request cmdDoc1 = new Request("PUT", "/test_spath_cmd/_doc/1?refresh=true");
+      cmdDoc1.setJsonEntity(
+          "{\"doc\": \"{\\\"user\\\":{\\\"name\\\":\\\"John\\\",\\\"age\\\":30}}\"}");
+      client().performRequest(cmdDoc1);
+
+      Request cmdDoc2 = new Request("PUT", "/test_spath_cmd/_doc/2?refresh=true");
+      cmdDoc2.setJsonEntity(
+          "{\"doc\": \"{\\\"user\\\":{\\\"name\\\":\\\"Alice\\\",\\\"age\\\":25}}\"}");
+      client().performRequest(cmdDoc2);
+    }
 
     // Auto-extract mode: null input handling (doc 1 establishes mapping, doc 2 has null)
-    Request nullDoc1 = new Request("PUT", "/test_spath_null/_doc/1?refresh=true");
-    nullDoc1.setJsonEntity("{\"doc\": \"{\\\"n\\\": 1}\"}");
-    client().performRequest(nullDoc1);
+    if (!TestUtils.isIndexExist(client(), "test_spath_null")) {
+      TestUtils.createIndexByRestClient(client(), "test_spath_null", SIMPLE_DOC_MAPPING);
+
+      Request nullDoc1 = new Request("PUT", "/test_spath_null/_doc/1?refresh=true");
+      nullDoc1.setJsonEntity("{\"doc\": \"{\\\"n\\\": 1}\"}");
+      client().performRequest(nullDoc1);
 
-    Request nullDoc2 = new Request("PUT", "/test_spath_null/_doc/2?refresh=true");
-    nullDoc2.setJsonEntity("{\"doc\": null}");
-    client().performRequest(nullDoc2);
+      Request nullDoc2 = new Request("PUT", "/test_spath_null/_doc/2?refresh=true");
+      nullDoc2.setJsonEntity("{\"doc\": null}");
+      client().performRequest(nullDoc2);
+    }
   }
 
   @Test