Phase 1: extract ANSI SQL logic from UnifiedQueryPlanner rather than
copying the whole file. Note mock schema is temporary until replaced
by Analytics engine SchemaProvider in Phase 4.

Phase 4: add reference link to OpenSearch sandbox plugins.

Add Calcite native SQL parser path (SqlParser -> SqlValidator ->
SqlToRelConverter -> RelNode) to UnifiedQueryPlanner for SQL queries.
PPL path remains unchanged using ANTLR parser -> AST -> CalciteRelNodeVisitor.

Logical optimization deferred to Phase 4 when Analytics engine schema
with pushdown rules is integrated.

Phase 2: PPL queries against a schema with all 5 standard Calcite
types (TIMESTAMP, DATE, TIME, VARBINARY, VARCHAR) produce RelNode
plans with standard SqlTypeName preserved — no UDT interference.

Key Area 1 finding: when schema bypasses OpenSearchTypeFactory,
PPL datetime functions (hour, day) resolve correctly via
PPLTypeChecker bridge and return standard INTEGER type.

Phase 3: Wire end-to-end unified query pipeline:
- AnalyticsExecutionEngine stubs transport action handoff to Analytics
  engine, returns empty results (TODO: serialize RelNode and submit)
- RestUnifiedQueryAction routes through UnifiedQueryPlanner -> RelNode
  -> AnalyticsExecutionEngine, formats via JdbcResponseFormatter
- RestSqlAction routes SQL queries with 'parquet_' to unified path
- RestPPLQueryAction routes PPL queries with 'parquet_' to unified path
- Add :api dependency to legacy/ and plugin/ modules

… builder

Phase 4: Analytics engine integration:
- New analytics-engine-stub/ submodule with SPI interfaces copied from
  analytics-framework (EngineContext, QueryPlanExecutor, SchemaProvider,
  EngineBridge, AnalyticsBackEndPlugin)
- OpenSearchSchemaBuilder copied from analytics-engine: builds Calcite
  SchemaPlus from ClusterState index mappings with standard SqlTypeName
- RestUnifiedQueryAction now uses real cluster state schema via
  OpenSearchSchemaBuilder instead of empty context
- Wire ClusterService through RestSqlAction and RestPPLQueryAction

Verify end-to-end flow: REST routing -> UnifiedQueryPlanner -> RelNode
-> AnalyticsExecutionEngine (stub) -> JdbcResponseFormatter.

AnalyticsExecutionEngine now derives schema from RelNode row type
instead of returning empty schema, enabling proper JDBC response
with correct column names and types.

Tests: SQL select with filter, SQL aggregate, non-parquet regression.

Add 7 integration tests covering SQL/PPL query and explain paths:
- SQL select with filter, SQL aggregate
- PPL where+project, PPL stats
- PPL datetime function (Key Area 1: no UDT in plan)
- PPL match() search function (MAP arguments in plan)
- Non-parquet regression test

Each test uses fluent withSQL/withPPL().verifySchema().verifyDataRows()
.verifyExplain() pattern asserting full logical plan output.

Refactor: move isUnifiedQueryPath() to RestUnifiedQueryAction,
deduplicate routing logic from RestSqlAction and RestPPLQueryAction.

Key findings from Phase 5 investigation:
- Transport action is NOT needed: both plugins run in same JVM
- Analytics engine uses ExtensiblePlugin for SPI discovery, not
  transport actions. Exposes QueryPlanExecutor via Guice bindings.
- SQL plugin has its own private Guice injector, isolated from the
  node-level injector where Analytics engine bindings live.
- RelNode can be passed directly in-process, no serialization needed.
- Calcite JSON serializer works as fallback for future cross-node needs.

Replace Phase 5 (serialization) and Phase 6 (transport action) with
Phase 5 (direct Guice integration with QueryPlanExecutor).

…findings

Key finding: each OpenSearch plugin gets its own URLClassLoader.
Even though both SQL and Analytics plugins bundle calcite-core:1.41.0,
RelNode is a different Class in each classloader -> ClassCastException.

Solution: SQL plugin declares extendedPlugins = ['analytics-engine'],
inheriting Analytics engine's classloader as parent. Both share the
same Calcite classes, enabling direct RelNode passing without
serialization.

Calcite JSON serialization validated as fallback option.

Phase 5: Direct plugin extension integration:
- Remove analytics-engine-stub module, use real analytics-framework
  and analytics-engine jars from OpenSearch sandbox build in libs/
- SQL plugin declares extendedPlugins = ['analytics-engine'], sharing
  Calcite classloader — no serialization needed for RelNode handoff
- AnalyticsExecutionEngine uses real QueryPlanExecutor interface
- Exclude overlapping jars from SQL plugin zip to avoid jar hell
- Analytics-engine plugin loaded in integ-test cluster
- All 7 ITs pass with real analytics-engine plugin loaded

…atting

Wire Iterable<Object[]> from QueryPlanExecutor through ExprTupleValue
to the existing JdbcResponseFormatter chain:
- Each Object[] row mapped to ExprTupleValue keyed by column names
  from RelNode.getRowType()
- ExprValueUtils.fromObjectValue() handles all standard Java types
- QueryResponse(Schema, List<ExprValue>, Cursor) flows through
  existing formatter unchanged

Phase 6 cross-cutting concerns:
- Schedule execution on sql-worker thread pool to avoid blocking
  transport threads (same pattern as OpenSearchExecutionEngine)
- Log planning and execution time with [unified] prefix
- Increment REQ_TOTAL/REQ_COUNT_TOTAL on success,
  FAILED_REQ_COUNT_SYS on failure
- Update PoC result doc with observability and thread management
  responsibilities

Demonstrate RelNode object tree structure via RelJsonWriter:
- demoTableScanIsStandardCalcite: LogicalTableScan with no custom node
- demoDatetimeFunctionProducesStandardTypes: HOUR as UDF producing
  standard INTEGER type, no UDT
- demoMatchFunctionIsPplUdf: match() as PPL UDF with MAP operands,
  class=UserDefinedFunctionBuilder - Analytics engine must handle/reject

Add UnifiedQueryPlanner.optimize() API:
- Runs VolcanoPlanner with adapter-specific pushdown rules
- Test simulates Analytics engine with custom EngineTableScan and
  filter absorption rule: LogicalFilter absorbed into EngineTableScan
  after optimize()