Rename plugin interfaces and default implementations.

Wire up a ppl front-end using UnifiedQueryAPI from sql plugin.

Signed-off-by: Marc Handalian <marc.handalian@gmail.com>

Author: mch2

sandbox/plugins/analytics-engine/build.gradle

@@ -0,0 +1,59 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Runtime module for the query engine.
+ * Provides scheduler, driver, transport actions, and operator implementations.
+ * Depends on libs/query-engine-framework for types and interfaces.
+ */
+
+opensearchplugin {
+  description = 'Query engine runtime module: scheduler, driver, operators, transport.'
+  classname = 'org.opensearch.fe.ppl.DefaultQueryEnginePlugin'
+}
+
+def calciteVersion = '1.41.0'
+
+dependencies {
+  implementation "org.apache.calcite:calcite-core:${calciteVersion}"
+  implementation "org.apache.calcite:calcite-linq4j:${calciteVersion}"
+  implementation "org.apache.calcite.avatica:avatica-core:1.27.0"
+  implementation "com.google.guava:guava:${versions.guava}"
+  runtimeOnly "com.google.guava:failureaccess:1.0.2"
+
+  // Calcite runtime dependencies
+  runtimeOnly "org.jooq:joou-java-6:0.9.4"
+  runtimeOnly "com.jayway.jsonpath:json-path:2.9.0"
+  runtimeOnly "org.codehaus.janino:janino:3.1.12"
+  runtimeOnly "org.codehaus.janino:commons-compiler:3.1.12"
+  runtimeOnly "org.apache.commons:commons-math3:3.6.1"
+  runtimeOnly "org.slf4j:slf4j-api:${versions.slf4j}"
+  runtimeOnly "commons-codec:commons-codec:${versions.commonscodec}"
+  runtimeOnly "org.locationtech.jts:jts-core:${versions.jts}"
+  runtimeOnly 'com.esri.geometry:esri-geometry-api:2.2.4'
+
+  compileOnly 'org.checkerframework:checker-qual:3.43.0'
+}
+
+configurations.all {
+  resolutionStrategy {
+    force 'com.google.guava:guava:33.4.0-jre'
+    force 'com.google.guava:failureaccess:1.0.2'
+    force 'com.google.errorprone:error_prone_annotations:2.36.0'
+    force 'org.checkerframework:checker-qual:3.43.0'
+  }
+}
+
+// Suppress -Werror and annotation warnings from Arrow dependency jars
+tasks.withType(JavaCompile).configureEach {
+  doFirst {
+    options.compilerArgs.removeAll(['-Werror'])
+    options.compilerArgs.removeIf { it.startsWith('-Xlint') || it.startsWith('-Xdoclint') }
+    options.compilerArgs << '-Xlint:none'
+  }
+}

sandbox/plugins/analytics-engine/src/main/java/org/opensearch/fe/ppl/AnalyticsEnginePlugin.java

@@ -0,0 +1,72 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.fe.ppl;
+
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.env.Environment;
+import org.opensearch.env.NodeEnvironment;
+import org.opensearch.plugins.ActionPlugin;
+import org.opensearch.plugins.AnalyticsBackEndPlugin;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.plugins.QueryEnginePlugin;
+import org.opensearch.plugins.QueryPlanExecutor;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.script.ScriptService;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.client.Client;
+import org.opensearch.watcher.ResourceWatcherService;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * Java-based Distributed Query Executor implementation.
+ * Evolves from the former query-engine module plugin. Implements the {@link QueryEnginePlugin}
+ * interface as the first concrete DQE implementation.
+ *
+ * <p>Responsibilities:
+ * <ul>
+ *   <li>Create the {@link PlanExecutor} as the {@link QueryPlanExecutor} implementation</li>
+ *   <li>Expose via {@link #getExecutor()}
+ * </ul>
+ */
+public class AnalyticsEnginePlugin extends Plugin implements QueryEnginePlugin, ActionPlugin {
+
+    private PlanExecutor queryExecutorService;
+
+    @Override
+    public Collection<Object> createComponents(
+        Client client,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ResourceWatcherService resourceWatcherService,
+        ScriptService scriptService,
+        NamedXContentRegistry xContentRegistry,
+        Environment environment,
+        NodeEnvironment nodeEnvironment,
+        NamedWriteableRegistry namedWriteableRegistry,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        Supplier<RepositoriesService> repositoriesServiceSupplier,
+        Collection<AnalyticsBackEndPlugin> backEnds
+    ) {
+        this.queryExecutorService = new PlanExecutor();
+
+        // TODO - do something with back-ends/engine implementations
+        return List.of(queryExecutorService);
+    }
+
+    @Override
+    public QueryPlanExecutor getExecutor() {
+        return queryExecutorService;
+    }
+}

sandbox/plugins/analytics-engine/src/main/java/org/opensearch/fe/ppl/PlanExecutor.java

@@ -0,0 +1,50 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.fe.ppl;
+
+import org.apache.calcite.rel.RelNode;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.plugins.QueryPlanExecutor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * {@link QueryPlanExecutor} implementation in the query-engine module.
+ * Translates logical fragments (RelNode trees) into OpenSearch query
+ * operations and returns result rows.
+ *
+ * <p>The parameters are typed as {@code Object} because the {@link QueryPlanExecutor}
+ * interface lives in {@code server/plugins} which must not depend on Calcite.
+ * This implementation casts them to the appropriate Calcite types internally.</p>
+ *
+ * <p>Currently a stub that logs the received logical plan and returns
+ * placeholder rows matching the fragment's field count.</p>
+ * // TODO: call this something.. better
+ */
+public class PlanExecutor implements QueryPlanExecutor {
+
+    private static final Logger logger = LogManager.getLogger(PlanExecutor.class);
+
+    @Override
+    public Iterable<Object[]> execute(Object logicalFragment, Object context) {
+        // TODO: This is a stub for now, just logs the RelNode fragment.
+        RelNode fragment = (RelNode) logicalFragment;
+        int fieldCount = fragment.getRowType().getFieldCount();
+
+        logger.info("[PlanExecutor] Executing fragment with {} fields: {}", fieldCount, fragment.explain());
+
+        // Stub: return an empty result set.
+        // A real implementation would translate the fragment into OpenSearch
+        // query operations, execute against OpenSearch shards, and return rows.
+        List<Object[]> rows = new ArrayList<>();
+        return rows;
+    }
+}

sandbox/plugins/analytics-engine/src/test/java/org/opensearch/fe/ppl/PlanExecutorTests.java

@@ -0,0 +1,119 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.fe.ppl;
+
+import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.plan.hep.HepPlanner;
+import org.apache.calcite.plan.hep.HepProgramBuilder;
+import org.apache.calcite.rel.AbstractRelNode;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.opensearch.test.OpenSearchTestCase;
+
+/**
+ * Tests for {@link PlanExecutor}.
+ */
+public class PlanExecutorTests extends OpenSearchTestCase {
+
+    private RelDataTypeFactory typeFactory;
+    private RelOptCluster cluster;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        typeFactory = new JavaTypeFactoryImpl();
+        RexBuilder rexBuilder = new RexBuilder(typeFactory);
+        HepPlanner planner = new HepPlanner(new HepProgramBuilder().build());
+        cluster = RelOptCluster.create(planner, rexBuilder);
+    }
+
+    /**
+     * Test that execute() returns an iterable and does not throw for a valid fragment.
+     */
+    public void testExecuteReturnsIterableForValidFragment() {
+        PlanExecutor service = new PlanExecutor();
+
+        RelNode fragment = createRelNodeWithFieldCount(3);
+        Object context = new Object();
+
+        Iterable<Object[]> result = service.execute(fragment, context);
+        assertNotNull("execute() should return a non-null Iterable", result);
+    }
+
+    /**
+     * Test that returned rows have correct length matching the fragment's field count.
+     */
+    public void testReturnedRowsMatchFieldCount() {
+        PlanExecutor service = new PlanExecutor();
+
+        int fieldCount = 5;
+        RelNode fragment = createRelNodeWithFieldCount(fieldCount);
+        Object context = new Object();
+
+        Iterable<Object[]> result = service.execute(fragment, context);
+        for (Object[] row : result) {
+            assertEquals("Each row should have length equal to fragment field count", fieldCount, row.length);
+        }
+    }
+
+    /**
+     * Test that execute() works with a single-field fragment.
+     */
+    public void testExecuteWithSingleFieldFragment() {
+        PlanExecutor service = new PlanExecutor();
+
+        RelNode fragment = createRelNodeWithFieldCount(1);
+        Object context = new Object();
+
+        Iterable<Object[]> result = service.execute(fragment, context);
+        assertNotNull(result);
+        for (Object[] row : result) {
+            assertEquals(1, row.length);
+        }
+    }
+
+    /**
+     * Test that execute() casts the logicalFragment to RelNode.
+     * Passing a non-RelNode should throw ClassCastException.
+     */
+    public void testExecuteThrowsOnInvalidFragmentType() {
+        PlanExecutor service = new PlanExecutor();
+
+        expectThrows(ClassCastException.class, () -> { service.execute("not a RelNode", new Object()); });
+    }
+
+    private RelNode createRelNodeWithFieldCount(int fieldCount) {
+        RelDataType rowType = buildRowType(fieldCount);
+        return new StubRelNode(cluster, cluster.traitSet(), rowType);
+    }
+
+    private RelDataType buildRowType(int fieldCount) {
+        RelDataTypeFactory.Builder builder = typeFactory.builder();
+        for (int i = 0; i < fieldCount; i++) {
+            builder.add("field_" + i, SqlTypeName.VARCHAR);
+        }
+        return builder.build();
+    }
+
+    /**
+     * Minimal concrete RelNode for testing. Extends AbstractRelNode
+     * which provides default implementations for all RelNode methods.
+     */
+    private static class StubRelNode extends AbstractRelNode {
+        StubRelNode(RelOptCluster cluster, RelTraitSet traitSet, RelDataType rowType) {
+            super(cluster, traitSet);
+            this.rowType = rowType;
+        }
+    }
+}