diff --git a/plugins/engine-datafusion/Cargo.toml b/plugins/engine-datafusion/Cargo.toml
index cead877ac0d2e..eeda4ae4cbefa 100644
--- a/plugins/engine-datafusion/Cargo.toml
+++ b/plugins/engine-datafusion/Cargo.toml
@@ -9,6 +9,10 @@ members = [
 datafusion = "52.1.0"
 datafusion-expr = "52.1.0"
 datafusion-datasource = "52.1.0"
+datafusion-datasource-parquet = "52.1.0"
+datafusion-common = "52.1.0"
+datafusion-execution = "52.1.0"
+datafusion-physical-expr = "52.1.0"
 arrow-json = "57.3.0"
 arrow = { version = "57.3.0", features = ["ffi", "ipc_compression"] }
 arrow-array = "57.3.0"
@@ -86,3 +90,23 @@ codegen-units = 1    # More parallel compilation
 incremental = true    # Enable incremental compilation
 debug = "full"
 strip = false
+
+# Patch arrow/parquet to local arrow-rs with sparse column chunk fix
+# Required by indexed-table crate for correct page index handling
+# https://github.com/apache/arrow-rs/pull/9301/changes
+#[patch.crates-io]
+#parquet = { path = "../../../arrow-rs/parquet" }
+#arrow = { path = "../../../arrow-rs/arrow" }
+#arrow-array = { path = "../../../arrow-rs/arrow-array" }
+#arrow-buffer = { path = "../../../arrow-rs/arrow-buffer" }
+#arrow-data = { path = "../../../arrow-rs/arrow-data" }
+#arrow-schema = { path = "../../../arrow-rs/arrow-schema" }
+#arrow-select = { path = "../../../arrow-rs/arrow-select" }
+#arrow-ipc = { path = "../../../arrow-rs/arrow-ipc" }
+#arrow-cast = { path = "../../../arrow-rs/arrow-cast" }
+#arrow-ord = { path = "../../../arrow-rs/arrow-ord" }
+#arrow-string = { path = "../../../arrow-rs/arrow-string" }
+#arrow-row = { path = "../../../arrow-rs/arrow-row" }
+#arrow-csv = { path = "../../../arrow-rs/arrow-csv" }
+#arrow-json = { path = "../../../arrow-rs/arrow-json" }
+#arrow-arith = { path = "../../../arrow-rs/arrow-arith" }
diff --git a/plugins/engine-datafusion/jni/Cargo.toml b/plugins/engine-datafusion/jni/Cargo.toml
index 011498ed186a4..d7998381c5ae1 100644
--- a/plugins/engine-datafusion/jni/Cargo.toml
+++ b/plugins/engine-datafusion/jni/Cargo.toml
@@ -14,6 +14,9 @@ crate-type = ["cdylib"]
 datafusion = { workspace = true }
 datafusion-expr = { workspace = true }
 datafusion-datasource = { workspace = true }
+datafusion-datasource-parquet = { workspace = true }
+datafusion-common = { workspace = true }
+datafusion-execution = { workspace = true }
 arrow-json = { workspace = true }
 arrow = { workspace = true }
 #arrow = "55.2.0"
@@ -50,6 +53,7 @@ log ={ workspace = true }
 
 # Shared OpenSearch utilities
 vectorized-exec-spi = { path = "../../../libs/vectorized-exec-spi/rust" }
+
 # Parquet support
 parquet = { workspace = true }
 
@@ -72,6 +76,7 @@ tempfile ={ workspace = true }
 chrono = { workspace = true }
 
 async-trait = { workspace = true }
+bytes = "1.5"
 itertools = { workspace = true }
 rstest = { workspace = true }
 regex = { workspace = true }
diff --git a/plugins/engine-datafusion/jni/src/absolute_row_id_optimizer.rs b/plugins/engine-datafusion/jni/src/absolute_row_id_optimizer.rs
index a29981bb8d3cf..6db31bffcfb59 100644
--- a/plugins/engine-datafusion/jni/src/absolute_row_id_optimizer.rs
+++ b/plugins/engine-datafusion/jni/src/absolute_row_id_optimizer.rs
@@ -111,9 +111,11 @@ impl AbsoluteRowIdOptimizer {
         let (new_schema, new_projections) =
             self.build_updated_file_source_schema(datasource, data_source_exec_schema.clone());
 
+        // Build a new TableSchema with partition columns from the original source
         let table_partition_cols = datasource.table_partition_cols().clone();
         let new_table_schema = TableSchema::new(new_schema.clone(), table_partition_cols);
 
+        // Create a new ParquetSource with the updated schema
         use datafusion::datasource::physical_plan::ParquetSource;
         let new_file_source = Arc::new(ParquetSource::new(new_table_schema));
 
@@ -121,7 +123,6 @@ impl AbsoluteRowIdOptimizer {
             .with_source(new_file_source)
             .with_projection_indices(Some(new_projections))
             .expect("Failed to set projection indices")
-            .with_statistics(datasource.statistics().add_column_statistics(ColumnStatistics::new_unknown()))
             .build();
 
         let new_datasource = DataSourceExec::from_data_source(file_scan_config);
diff --git a/plugins/engine-datafusion/jni/src/indexed_query_executor.rs b/plugins/engine-datafusion/jni/src/indexed_query_executor.rs
new file mode 100644
index 0000000000000..ceabbb34ec5b2
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_query_executor.rs
@@ -0,0 +1,126 @@
+/*
+ * 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.
+ */
+
+/**
+Indexed query executor — bridges indexed-table into engine-datafusion.
+
+Registers an IndexedTableProvider (Lucene index + parquet) as the table,
+then executes the substrait plan against it — same as the normal DF path
+but with index-accelerated reads instead of full parquet scans.
+**/
+
+use std::sync::Arc;
+
+use datafusion::execution::context::SessionContext;
+use datafusion::physical_plan::execute_stream;
+use datafusion::prelude::SessionConfig;
+use jni::sys::jlong;
+use prost::Message;
+
+use crate::indexed_table::index::BitsetMode;
+use crate::indexed_table::table_provider::{IndexedTableConfig, IndexedTableProvider};
+use crate::indexed_table::jni_helpers::build_segments;
+
+use crate::executor::DedicatedExecutor;
+use crate::query_executor::get_cross_rt_stream;
+use crate::DataFusionRuntime;
+
+use datafusion::common::DataFusionError;
+use datafusion_substrait::logical_plan::consumer::from_substrait_plan;
+use datafusion_substrait::substrait::proto::Plan;
+use datafusion_substrait::substrait::proto::extensions::simple_extension_declaration::MappingType;
+use vectorized_exec_spi::log_error;
+
+/// Execute an indexed query with a substrait plan and return a CrossRtStream pointer.
+pub async fn execute_indexed_query_stream(
+    weight_ptr: i64,
+    segment_max_docs: Vec<i64>,
+    parquet_paths: Vec<String>,
+    table_name: String,
+    plan_bytes: Vec<u8>,
+    num_partitions: usize,
+    bitset_mode: BitsetMode,
+    is_query_plan_explain_enabled: bool,
+    jvm: Arc<jni::JavaVM>,
+    searcher_class_ref: jni::objects::GlobalRef,
+    runtime: &DataFusionRuntime,
+    cpu_executor: DedicatedExecutor,
+) -> Result<jlong, DataFusionError> {
+    let t0 = std::time::Instant::now();
+
+    let searcher = Arc::new(crate::indexed_table::JniShardSearcher::new(
+        Arc::clone(&jvm),
+        weight_ptr,
+        searcher_class_ref,
+        segment_max_docs.clone(),
+    )) as Arc<dyn crate::indexed_table::index::ShardSearcher>;
+
+    let (segments, schema) = build_segments(&parquet_paths, &segment_max_docs)
+        .map_err(|e| DataFusionError::Execution(format!("build_segments: {}", e)))?;
+
+    let provider = IndexedTableProvider::try_new(
+        IndexedTableConfig::new(searcher, segments, schema)
+            .with_bitset_mode(bitset_mode)
+            .with_partitions(num_partitions),
+    )?;
+
+    let config = SessionConfig::new()
+        .with_target_partitions(num_partitions);
+
+    let ctx = SessionContext::new_with_config(config);
+    ctx.register_table(&table_name, Arc::new(provider))
+        .map_err(|e| DataFusionError::Execution(format!("register_table: {}", e)))?;
+
+    let t_setup = t0.elapsed();
+
+    let substrait_plan = Plan::decode(plan_bytes.as_slice())
+        .map_err(|e| DataFusionError::Execution(format!("Failed to decode Substrait: {}", e)))?;
+
+    let mut modified_plan = substrait_plan.clone();
+    for ext in modified_plan.extensions.iter_mut() {
+        if let Some(mapping_type) = &mut ext.mapping_type {
+            if let MappingType::ExtensionFunction(func) = mapping_type {
+                if func.name == "approx_count_distinct:any" {
+                    func.name = "approx_distinct:any".to_string();
+                }
+            }
+        }
+    }
+
+    let logical_plan = from_substrait_plan(&ctx.state(), &modified_plan).await
+        .map_err(|e| { eprintln!("Failed to convert Substrait plan: {}", e); e })?;
+
+    let mut dataframe = ctx.execute_logical_plan(logical_plan).await
+        .map_err(|e| { eprintln!("Failed to execute logical plan: {}", e); e })?;
+
+    let physical_plan = dataframe.clone().create_physical_plan().await?;
+
+    let t_plan = t0.elapsed();
+
+    // if is_query_plan_explain_enabled {
+    //     log_error!("---- Indexed Query Explain Plan ----");
+    //     let plan_str = format!("{}", datafusion::physical_plan::displayable(physical_plan.as_ref()).indent(true));
+    //     for line in plan_str.lines() {
+    //         log_error!("  {}", line);
+    //     }
+    // }
+
+    if is_query_plan_explain_enabled {
+        println!("---- Explain plan ----");
+        let clone_df = dataframe.clone().explain(false, true).expect("Failed to explain plan");
+        clone_df.show().await?;
+    }
+
+    let df_stream = execute_stream(physical_plan, ctx.task_ctx())?;
+
+    let t_exec = t0.elapsed();
+    eprintln!("[INDEXED-TIMING] setup={}ms, plan={}ms, execute_stream={}ms, explain={}",
+        t_setup.as_millis(), (t_plan - t_setup).as_millis(), (t_exec - t_plan).as_millis(), is_query_plan_explain_enabled);
+
+    Ok(get_cross_rt_stream(cpu_executor, df_stream))
+}
diff --git a/plugins/engine-datafusion/jni/src/indexed_table/index.rs b/plugins/engine-datafusion/jni/src/indexed_table/index.rs
new file mode 100644
index 0000000000000..c96ee7b138044
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_table/index.rs
@@ -0,0 +1,81 @@
+/**
+Core index traits — the contract between the index and the query engine.
+
+These two traits are all the core crate needs. How the searcher was created
+(Lucene JNI, Tantivy, test stub, Java-side Weight pointer) is irrelevant here.
+
+ShardSearcher   (Equivalent of Lucene's Weight — once per shard)
+  └── SegmentCollector (Equivalent of Lucene's Scorer — once per segment)
+        └── collect(range) → Vec<u64> (Collects matching doc IDs as bitsets within the given doc range)
+**/
+
+use std::fmt::Debug;
+use std::sync::Arc;
+
+/// A collector that retrieves matching doc IDs as a bitset for a row group docs
+/// range within a segment.
+///
+/// The `collect` method returns a bitset (Vec<u64>) where each set bit represents
+/// a matching doc ID relative to `min_doc`.
+pub trait RowGroupDocsCollector: Send + Sync + Debug {
+    /// Collect matching doc IDs in `[min_doc, max_doc)` as a bitset.
+    ///
+    /// TODO : change this to direct native memory bitset
+    ///
+    /// Each u64 word represents 64 consecutive doc IDs starting from `min_doc`.
+    /// Bit `i` in word `j` represents doc ID `min_doc + j*64 + i`.
+    ///
+    /// The collector may be called multiple times with increasing ranges
+    /// (forward-only iteration).
+    fn collect(&self, min_doc: i32, max_doc: i32) -> Result<Vec<u64>, String>;
+}
+
+/// A searcher scoped to a single shard (index), created once per query.
+///
+/// Analogous to Lucene's `Weight` — expensive to create (parses query, builds
+/// automaton for wildcards, etc.), but creating segment collectors from it is cheap.
+///
+/// Right now  : Java walks the query's boolean tree, builds a single Lucene BooleanQuery
+/// that covers all indexed columns, and produces one `ShardSearcher`. The bitset
+/// it returns is a superset of all rows matching the indexed portion of the query.
+///
+/// TODO : Handle complex nested boolean queries which will need multiple scorers.
+pub trait ShardSearcher: Send + Sync + Debug {
+    /// Number of segments in this shard.
+    fn segment_count(&self) -> usize;
+
+    /// Max doc ID for a specific segment.
+    fn segment_max_doc(&self, segment_ord: usize) -> Result<i64, String>;
+
+    /// Create a collector for a specific segment and doc ID range.
+    ///
+    /// The collector will only return docs in `[doc_min, doc_max)` as we stream through the row groups
+    /// This is cheap — analogous to `Weight.scorer(leafCtx, doc_min, doc_max)` in Lucene.
+    fn collector(
+        &self,
+        segment_ord: usize,
+        doc_min: i32,
+        doc_max: i32,
+    ) -> Result<Arc<dyn RowGroupDocsCollector>, String>;
+}
+
+
+/// How the index bitset relates to the parquet (non-indexed) filters.
+///
+/// Java decides this based on the top-level query structure:
+///
+/// In both cases, the result is a superset of the true answer. DataFusion's
+/// residual filter cleans up false positives after parquet reads.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BitsetMode {
+    /// Intersect bitset with page pruner ranges (default).
+    And,
+    /// Union bitset with page pruner candidate rows.
+    Or,
+}
+
+impl Default for BitsetMode {
+    fn default() -> Self {
+        BitsetMode::And
+    }
+}
diff --git a/plugins/engine-datafusion/jni/src/indexed_table/jni_helpers.rs b/plugins/engine-datafusion/jni/src/indexed_table/jni_helpers.rs
new file mode 100644
index 0000000000000..23ee0c899d645
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_table/jni_helpers.rs
@@ -0,0 +1,68 @@
+/**
+Helpers for building indexed table segments from parquet file paths.
+**/
+
+use super::parquet_bridge;
+use super::stream::RowGroupInfo;
+use super::table_provider::{coerce_binary_to_string, SegmentFileInfo};
+
+/// Build `SegmentFileInfo` from parquet paths + segment max docs.
+///
+/// Each parquet file is one segment. Reads parquet metadata to discover
+/// row groups (count + row counts).
+pub fn build_segments(
+    parquet_paths: &[String],
+    segment_max_docs: &[i64],
+) -> Result<(Vec<SegmentFileInfo>, arrow::datatypes::SchemaRef), String> {
+    use std::path::PathBuf;
+
+    if parquet_paths.len() != segment_max_docs.len() {
+        return Err(format!(
+            "parquet_paths.len()={} != segment_max_docs.len()={}",
+            parquet_paths.len(),
+            segment_max_docs.len()
+        ));
+    }
+
+    let mut segments = Vec::with_capacity(parquet_paths.len());
+    let mut schema: Option<arrow::datatypes::SchemaRef> = None;
+
+    for (seg_ord, (path, &max_doc)) in parquet_paths.iter().zip(segment_max_docs).enumerate() {
+        let file = std::fs::File::open(path).map_err(|e| format!("open {}: {}", path, e))?;
+        let file_size = file
+            .metadata()
+            .map_err(|e| format!("stat {}: {}", path, e))?
+            .len();
+
+        let (file_schema, pq_meta) = parquet_bridge::load_parquet_metadata(&file)
+            .map_err(|e| format!("parquet metadata {}: {}", path, e))?;
+
+        if schema.is_none() {
+            schema = Some(coerce_binary_to_string(file_schema));
+        }
+
+        let mut row_groups = Vec::new();
+        let mut offset: i64 = 0;
+        for rg_idx in 0..pq_meta.num_row_groups() {
+            let num_rows = pq_meta.row_group(rg_idx).num_rows();
+            row_groups.push(RowGroupInfo {
+                index: rg_idx,
+                first_row: offset,
+                num_rows,
+            });
+            offset += num_rows;
+        }
+
+        segments.push(SegmentFileInfo {
+            segment_ord: seg_ord as i32,
+            max_doc,
+            parquet_path: PathBuf::from(path),
+            parquet_size: file_size,
+            row_groups,
+            metadata: pq_meta,
+        });
+    }
+
+    let schema = schema.ok_or_else(|| "No parquet files provided".to_string())?;
+    Ok((segments, schema))
+}
diff --git a/plugins/engine-datafusion/jni/src/indexed_table/jni_searcher.rs b/plugins/engine-datafusion/jni/src/indexed_table/jni_searcher.rs
new file mode 100644
index 0000000000000..1cb954ea7552e
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_table/jni_searcher.rs
@@ -0,0 +1,208 @@
+/**
+JNI-backed `ShardSearcher` — wraps a Java-side Weight pointer.
+
+This is the "flipped" version of `LuceneIndexProvider`:
+- **Before**: Rust creates the Weight by calling into Java (`create_shard_weight`)
+- **Now**: Java creates the Weight and passes the raw pointer to Rust
+
+The `JniShardSearcher` implements `ShardSearcher` by calling back into Java
+for scorer creation and doc collection — same JNI methods, just driven from
+the Java side.
+
+```text
+Java: Weight weight = searcher.createWeight(query);
+      long weightPtr = storeWeight(weight);
+      nativeExecuteIndexedQuery(weightPtr, segmentInfos, ...);
+
+Rust: JniShardSearcher { weight_ptr, java_class }
+        .collector(seg, min, max)  →  calls Java createPartitionScorerFromShard
+        .collect(min, max)         →  calls Java getNextRowGroupDocs
+```
+**/
+
+use std::sync::Arc;
+
+use jni::objects::{GlobalRef, JClass, JValue};
+use jni::JavaVM;
+
+use super::index::{RowGroupDocsCollector, ShardSearcher};
+
+
+/// A `ShardSearcher` backed by a Java-side Weight pointer.
+///
+/// Created by the JNI entry point when Java passes a pre-built Weight.
+/// The Weight pointer is NOT owned — Java manages its lifecycle.
+pub struct JniShardSearcher {
+    jvm: Arc<JavaVM>,
+    weight_ptr: i64,
+    class_ref: GlobalRef,
+    segment_count: usize,
+    segment_max_docs: Vec<i64>,
+}
+
+impl JniShardSearcher {
+    /// Create from a Java-side Weight pointer.
+    ///
+    /// `segment_max_docs` is passed from Java (one entry per segment).
+    /// The Weight pointer is borrowed — caller (Java) owns it.
+    pub fn new(
+        jvm: Arc<JavaVM>,
+        weight_ptr: i64,
+        class_ref: GlobalRef,
+        segment_max_docs: Vec<i64>,
+    ) -> Self {
+        let segment_count = segment_max_docs.len();
+        Self {
+            jvm,
+            weight_ptr,
+            class_ref,
+            segment_count,
+            segment_max_docs,
+        }
+    }
+}
+
+impl std::fmt::Debug for JniShardSearcher {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("JniShardSearcher")
+            .field("weight_ptr", &self.weight_ptr)
+            .field("segment_count", &self.segment_count)
+            .finish()
+    }
+}
+
+impl ShardSearcher for JniShardSearcher {
+    fn segment_count(&self) -> usize {
+        self.segment_count
+    }
+
+    fn segment_max_doc(&self, segment_ord: usize) -> Result<i64, String> {
+        self.segment_max_docs
+            .get(segment_ord)
+            .copied()
+            .ok_or_else(|| {
+                format!(
+                    "segment_ord {} out of range ({})",
+                    segment_ord, self.segment_count
+                )
+            })
+    }
+
+    fn collector(
+        &self,
+        segment_ord: usize,
+        doc_min: i32,
+        doc_max: i32,
+    ) -> Result<Arc<dyn RowGroupDocsCollector>, String> {
+        let mut env = self
+            .jvm
+            .attach_current_thread()
+            .map_err(|e| format!("Failed to attach thread: {}", e))?;
+
+        let class: &JClass = self.class_ref.as_obj().into();
+
+        let scorer_ptr = env
+            .call_static_method(
+                class,
+                "createPartitionScorerFromShard",
+                "(JIII)J",
+                &[
+                    JValue::Long(self.weight_ptr),
+                    JValue::Int(segment_ord as i32),
+                    JValue::Int(doc_min),
+                    JValue::Int(doc_max),
+                ],
+            )
+            .map_err(|e| format!("createPartitionScorerFromShard failed: {}", e))?
+            .j()
+            .map_err(|e| format!("Failed to get long: {}", e))?;
+
+        if scorer_ptr < 0 {
+            return Err("No matches in segment (scorer_ptr < 0)".to_string());
+        }
+
+        let scorer_class_ref = env
+            .new_global_ref(class)
+            .map_err(|e| format!("Failed to create global ref: {}", e))?;
+
+        Ok(Arc::new(JniSegmentCollector {
+            jvm: Arc::clone(&self.jvm),
+            scorer_ptr,
+            class_ref: scorer_class_ref,
+        }))
+    }
+}
+
+/// A `SegmentCollector` backed by a Java-side PartitionScorer pointer.
+///
+/// The scorer pointer IS owned — dropped via `releasePartitionScorer`.
+struct JniSegmentCollector {
+    jvm: Arc<JavaVM>,
+    scorer_ptr: i64,
+    class_ref: GlobalRef,
+}
+
+impl std::fmt::Debug for JniSegmentCollector {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("JniSegmentCollector")
+            .field("scorer_ptr", &self.scorer_ptr)
+            .finish()
+    }
+}
+
+impl Drop for JniSegmentCollector {
+    fn drop(&mut self) {
+        if let Ok(mut env) = self.jvm.attach_current_thread() {
+            let class: &JClass = self.class_ref.as_obj().into();
+            let _ = env.call_static_method(
+                class,
+                "releasePartitionScorer",
+                "(J)V",
+                &[JValue::Long(self.scorer_ptr)],
+            );
+        }
+    }
+}
+
+impl RowGroupDocsCollector for JniSegmentCollector {
+    fn collect(&self, min_doc: i32, max_doc: i32) -> Result<Vec<u64>, String> {
+        let mut env = self
+            .jvm
+            .attach_current_thread()
+            .map_err(|e| format!("Failed to attach thread: {}", e))?;
+
+        let class: &JClass = self.class_ref.as_obj().into();
+
+        let result = env
+            .call_static_method(
+                class,
+                "getNextRowGroupDocs",
+                "(JII)[J",
+                &[
+                    JValue::Long(self.scorer_ptr),
+                    JValue::Int(min_doc),
+                    JValue::Int(max_doc),
+                ],
+            )
+            .map_err(|e| format!("getNextRowGroupDocs failed: {}", e))?;
+
+        let array_obj = result
+            .l()
+            .map_err(|e| format!("Failed to get array: {}", e))?;
+
+        let long_array = unsafe { jni::objects::JLongArray::from_raw(array_obj.as_raw()) };
+        let len = env
+            .get_array_length(&long_array)
+            .map_err(|e| format!("Failed to get array length: {}", e))? as usize;
+
+        if len == 0 {
+            return Ok(Vec::new());
+        }
+
+        let mut buf = vec![0i64; len];
+        env.get_long_array_region(&long_array, 0, &mut buf)
+            .map_err(|e| format!("Failed to get array region: {}", e))?;
+
+        Ok(buf.iter().map(|&v| v as u64).collect())
+    }
+}
diff --git a/plugins/engine-datafusion/jni/src/indexed_table/metrics.rs b/plugins/engine-datafusion/jni/src/indexed_table/metrics.rs
new file mode 100644
index 0000000000000..40e434689d713
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_table/metrics.rs
@@ -0,0 +1,106 @@
+/**
+Metrics for indexed search execution plans.
+
+- `PartitionMetrics` — registered against the parent ExecutionPlan, visible in EXPLAIN ANALYZE
+- `StreamMetrics` — lightweight handles passed to the stream for recording
+**/
+
+use std::sync::Arc;
+
+use datafusion::physical_plan::metrics::{
+    Count, ExecutionPlanMetricsSet, MetricBuilder, MetricsSet, Time,
+};
+
+/// Lightweight metric handles passed from the execution plan to the stream.
+///
+/// All fields are `Option` because standalone `IndexedExec` (not under a
+/// multi-segment parent) has no shared parent metrics to update.
+#[derive(Clone)]
+pub struct StreamMetrics {
+    pub output_rows: Option<Count>,
+    pub elapsed_compute: Option<Time>,
+    pub lucene_time: Option<Time>,
+    pub parquet_time: Option<Time>,
+    pub rows_matched: Option<Count>,
+    pub rows_pruned: Option<Count>,
+    pub row_selection_count: Option<Count>,
+    pub boolean_mask_count: Option<Count>,
+    pub rg_processed: Option<Count>,
+    pub rg_skipped: Option<Count>,
+    /// Accumulated inner DataSourceExec parquet metrics (shared across partitions).
+    pub inner_parquet_metrics: Option<Arc<std::sync::Mutex<Vec<MetricsSet>>>>,
+}
+
+impl StreamMetrics {
+    /// No-op metrics for standalone execution.
+    pub fn empty() -> Self {
+        Self {
+            output_rows: None,
+            elapsed_compute: None,
+            lucene_time: None,
+            parquet_time: None,
+            rows_matched: None,
+            rows_pruned: None,
+            row_selection_count: None,
+            boolean_mask_count: None,
+            rg_processed: None,
+            rg_skipped: None,
+            inner_parquet_metrics: None,
+        }
+    }
+}
+
+/// Per-partition metrics registered against the parent `ExecutionPlanMetricsSet`.
+pub struct PartitionMetrics {
+    pub output_rows: Count,
+    pub elapsed_compute: Time,
+    pub weight_time: Time,
+    pub scorer_time: Time,
+    pub lucene_time: Time,
+    pub parquet_time: Time,
+    pub rows_matched: Count,
+    pub rows_pruned_by_page_index: Count,
+    pub row_selection_count: Count,
+    pub boolean_mask_count: Count,
+    pub row_groups_processed: Count,
+    pub row_groups_skipped: Count,
+}
+
+impl PartitionMetrics {
+    pub fn new(metrics: &ExecutionPlanMetricsSet, partition: usize) -> Self {
+        Self {
+            output_rows: MetricBuilder::new(metrics).output_rows(partition),
+            elapsed_compute: MetricBuilder::new(metrics).elapsed_compute(partition),
+            weight_time: MetricBuilder::new(metrics).subset_time("weight_creation_time", partition),
+            scorer_time: MetricBuilder::new(metrics).subset_time("scorer_creation_time", partition),
+            lucene_time: MetricBuilder::new(metrics).subset_time("lucene_query_time", partition),
+            parquet_time: MetricBuilder::new(metrics).subset_time("parquet_read_time", partition),
+            rows_matched: MetricBuilder::new(metrics).counter("rows_matched", partition),
+            rows_pruned_by_page_index: MetricBuilder::new(metrics).counter("rows_pruned_by_page_index", partition),
+            row_selection_count: MetricBuilder::new(metrics).counter("strategy_row_selection", partition),
+            boolean_mask_count: MetricBuilder::new(metrics).counter("strategy_boolean_mask", partition),
+            row_groups_processed: MetricBuilder::new(metrics).counter("row_groups_processed", partition),
+            row_groups_skipped: MetricBuilder::new(metrics).counter("row_groups_skipped", partition),
+        }
+    }
+
+    /// Convert into `StreamMetrics` for passing to the stream.
+    pub fn into_stream_metrics(
+        self,
+        inner_parquet_metrics: Option<Arc<std::sync::Mutex<Vec<MetricsSet>>>>,
+    ) -> StreamMetrics {
+        StreamMetrics {
+            output_rows: Some(self.output_rows),
+            elapsed_compute: Some(self.elapsed_compute),
+            lucene_time: Some(self.lucene_time),
+            parquet_time: Some(self.parquet_time),
+            rows_matched: Some(self.rows_matched),
+            rows_pruned: Some(self.rows_pruned_by_page_index),
+            row_selection_count: Some(self.row_selection_count),
+            boolean_mask_count: Some(self.boolean_mask_count),
+            rg_processed: Some(self.row_groups_processed),
+            rg_skipped: Some(self.row_groups_skipped),
+            inner_parquet_metrics,
+        }
+    }
+}
diff --git a/plugins/engine-datafusion/jni/src/indexed_table/mod.rs b/plugins/engine-datafusion/jni/src/indexed_table/mod.rs
new file mode 100644
index 0000000000000..02a52cec7fc1e
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_table/mod.rs
@@ -0,0 +1,31 @@
+/**
+Index-accelerated parquet queries for DataFusion.
+
+Copied from the indexed_table POC crate for integration into engine-datafusion.
+
+Core modules:
+- `index` — traits: ShardSearcher, RowGroupDocsCollector, BitsetMode
+- `table_provider` — IndexedTableProvider (DataFusion TableProvider impl)
+- `stream` — IndexedExec streaming execution per segment
+- `partitioning` — row-group-aligned partition assignment
+- `page_pruner` — page-level pruning using parquet statistics
+- `parquet_bridge` — DataFusion parquet API isolation layer
+- `metrics` — execution plan metrics
+- `jni_searcher` — JniShardSearcher (JNI callbacks to Java)
+- `jni_helpers` — build_segments utility
+**/
+
+pub mod index;
+pub mod metrics;
+mod page_pruner;
+pub mod parquet_bridge;
+pub mod partitioning;
+pub mod stream;
+pub mod table_provider;
+pub mod jni_searcher;
+pub mod jni_helpers;
+
+pub use index::{BitsetMode, ShardSearcher};
+pub use jni_searcher::JniShardSearcher;
+pub use table_provider::{IndexedTableConfig, IndexedTableProvider};
+pub use jni_helpers::build_segments;
diff --git a/plugins/engine-datafusion/jni/src/indexed_table/page_pruner.rs b/plugins/engine-datafusion/jni/src/indexed_table/page_pruner.rs
new file mode 100644
index 0000000000000..a4bbcec9a5377
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_table/page_pruner.rs
@@ -0,0 +1,295 @@
+/**
+Page-level pruning using parquet page statistics.
+
+Filters row IDs based on page min/max statistics before reading data.
+This intersects Lucene's doc IDs with page ranges that could contain
+matching values, eliminating rows that can't satisfy the filter.
+**/
+use std::ops::Range;
+use std::sync::Arc;
+
+use datafusion::arrow::array::{Array, Int32Array, Int64Array};
+use datafusion::arrow::datatypes::SchemaRef;
+use datafusion::common::ScalarValue;
+use datafusion::logical_expr::{Expr, Operator};
+use datafusion::parquet::arrow::arrow_reader::statistics::StatisticsConverter;
+use datafusion::parquet::file::metadata::ParquetMetaData;
+
+#[derive(Debug, Clone)]
+struct ParsedFilter {
+    col_name: String,
+    op: Operator,
+    value: ScalarValue,
+}
+
+/// Per-row-group page pruner using page statistics.
+pub struct PagePruner {
+    filters: Vec<ParsedFilter>,
+    schema: SchemaRef,
+    metadata: Arc<ParquetMetaData>,
+}
+
+impl PagePruner {
+    pub fn new(schema: &SchemaRef, metadata: Arc<ParquetMetaData>, filters: &[Expr]) -> Self {
+        let parsed = filters.iter().filter_map(Self::parse_filter).collect();
+        Self {
+            filters: parsed,
+            schema: schema.clone(),
+            metadata,
+        }
+    }
+
+    fn parse_filter(filter: &Expr) -> Option<ParsedFilter> {
+        if let Expr::BinaryExpr(binary) = filter {
+            match (binary.left.as_ref(), binary.right.as_ref()) {
+                (Expr::Column(col), Expr::Literal(val, _)) => Some(ParsedFilter {
+                    col_name: col.name.clone(),
+                    op: binary.op.clone(),
+                    value: val.clone(),
+                }),
+                (Expr::Literal(val, _), Expr::Column(col)) => {
+                    let flipped_op = match &binary.op {
+                        Operator::Lt => Operator::Gt,
+                        Operator::LtEq => Operator::GtEq,
+                        Operator::Gt => Operator::Lt,
+                        Operator::GtEq => Operator::LtEq,
+                        other => other.clone(),
+                    };
+                    Some(ParsedFilter {
+                        col_name: col.name.clone(),
+                        op: flipped_op,
+                        value: val.clone(),
+                    })
+                }
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+
+    /// Compute page ranges that could match the filters for a row group.
+    ///
+    /// Returns `None` if page stats are unavailable (caller should assume all rows).
+    /// Returns `Some(vec![])` if no pages match (caller can skip entirely).
+    fn compute_page_ranges(&self, rg_idx: usize, rg_first_row: i64) -> Option<Vec<Range<i64>>> {
+        let (column_index, offset_index) = match (
+            self.metadata.column_index(),
+            self.metadata.offset_index(),
+        ) {
+            (Some(ci), Some(oi)) => (ci, oi),
+            _ => return None,
+        };
+
+        let parquet_schema = self.metadata.file_metadata().schema_descr();
+        let rg = self.metadata.row_group(rg_idx);
+        let rg_num_rows = rg.num_rows();
+
+        let mut combined_ranges: Option<Vec<Range<i64>>> = None;
+
+        for filter in &self.filters {
+            let converter = match StatisticsConverter::try_new(
+                &filter.col_name,
+                &self.schema,
+                parquet_schema,
+            ) {
+                Ok(c) => c,
+                Err(_) => continue,
+            };
+
+            let (mins, maxes) = match (
+                converter.data_page_mins(column_index, offset_index, [&rg_idx]),
+                converter.data_page_maxes(column_index, offset_index, [&rg_idx]),
+            ) {
+                (Ok(m), Ok(x)) => (m, x),
+                _ => continue,
+            };
+
+            let row_counts = match converter.data_page_row_counts(
+                offset_index,
+                self.metadata.row_groups(),
+                [&rg_idx],
+            ) {
+                Ok(Some(rc)) => rc,
+                _ => continue,
+            };
+
+            let num_pages = mins.len();
+            let mut page_start = rg_first_row;
+            let mut filter_ranges: Vec<Range<i64>> = Vec::new();
+
+            for page_idx in 0..num_pages {
+                let page_rows = if page_idx < row_counts.len() {
+                    row_counts.value(page_idx) as i64
+                } else {
+                    rg_num_rows / num_pages as i64
+                };
+
+                if Self::page_matches(&mins, &maxes, page_idx, &filter.op, &filter.value) {
+                    filter_ranges.push(page_start..page_start + page_rows);
+                }
+                page_start += page_rows;
+            }
+
+            filter_ranges.sort_by_key(|r| r.start);
+            let merged = Self::merge_ranges(filter_ranges);
+
+            combined_ranges = match combined_ranges {
+                None if merged.is_empty() => return Some(vec![]),
+                None => Some(merged),
+                Some(_) if merged.is_empty() => return Some(vec![]),
+                Some(existing) => {
+                    let intersected = Self::intersect_ranges(&existing, &merged);
+                    if intersected.is_empty() {
+                        return Some(vec![]);
+                    }
+                    Some(intersected)
+                }
+            };
+        }
+
+        combined_ranges
+    }
+
+    /// Return all row IDs within pages that match the filters for a row group.
+    ///
+    /// Expands matching page ranges into individual row IDs. Used for OR-mode
+    /// queries where the page pruner's candidates are UNION'd with index bitset rows.
+    pub fn candidate_row_ids(&self, rg_idx: usize, rg_first_row: i64, rg_num_rows: i64) -> Vec<i64> {
+        if self.filters.is_empty() {
+            return (rg_first_row..rg_first_row + rg_num_rows).collect();
+        }
+
+        let ranges = match self.compute_page_ranges(rg_idx, rg_first_row) {
+            Some(r) if r.is_empty() => return vec![],
+            Some(r) => r,
+            None => return (rg_first_row..rg_first_row + rg_num_rows).collect(),
+        };
+
+        let mut ids = Vec::new();
+        for range in &ranges {
+            let start = range.start.max(rg_first_row);
+            let end = range.end.min(rg_first_row + rg_num_rows);
+            for id in start..end {
+                ids.push(id);
+            }
+        }
+        ids
+    }
+
+    /// Filter row IDs by intersecting with page ranges (AND mode).
+    pub fn filter_row_ids(&self, rg_idx: usize, row_ids: &[i64], rg_first_row: i64) -> Vec<i64> {
+        if self.filters.is_empty() || row_ids.is_empty() {
+            return row_ids.to_vec();
+        }
+
+        match self.compute_page_ranges(rg_idx, rg_first_row) {
+            None => row_ids.to_vec(),
+            Some(ranges) if ranges.is_empty() => vec![],
+            Some(ranges) => Self::filter_by_ranges(row_ids, &ranges),
+        }
+    }
+
+    fn merge_ranges(ranges: Vec<Range<i64>>) -> Vec<Range<i64>> {
+        let mut merged: Vec<Range<i64>> = Vec::new();
+        for range in ranges {
+            if let Some(last) = merged.last_mut() {
+                if range.start <= last.end {
+                    last.end = last.end.max(range.end);
+                    continue;
+                }
+            }
+            merged.push(range);
+        }
+        merged
+    }
+
+    fn intersect_ranges(a: &[Range<i64>], b: &[Range<i64>]) -> Vec<Range<i64>> {
+        let mut result = Vec::new();
+        let (mut i, mut j) = (0, 0);
+        while i < a.len() && j < b.len() {
+            let start = a[i].start.max(b[j].start);
+            let end = a[i].end.min(b[j].end);
+            if start < end {
+                result.push(start..end);
+            }
+            if a[i].end < b[j].end {
+                i += 1;
+            } else {
+                j += 1;
+            }
+        }
+        result
+    }
+
+    fn filter_by_ranges(row_ids: &[i64], ranges: &[Range<i64>]) -> Vec<i64> {
+        let mut result = Vec::with_capacity(row_ids.len());
+        let mut range_idx = 0;
+        for &row_id in row_ids {
+            while range_idx < ranges.len() && ranges[range_idx].end <= row_id {
+                range_idx += 1;
+            }
+            if range_idx >= ranges.len() {
+                break;
+            }
+            if row_id >= ranges[range_idx].start && row_id < ranges[range_idx].end {
+                result.push(row_id);
+            }
+        }
+        result
+    }
+
+    fn page_matches(
+        mins: &Arc<dyn Array>,
+        maxes: &Arc<dyn Array>,
+        page_idx: usize,
+        op: &Operator,
+        value: &ScalarValue,
+    ) -> bool {
+        if let (Some(min_arr), Some(max_arr)) = (
+            mins.as_any().downcast_ref::<Int32Array>(),
+            maxes.as_any().downcast_ref::<Int32Array>(),
+        ) {
+            let filter_val = match value {
+                ScalarValue::Int32(Some(v)) => *v,
+                ScalarValue::Int64(Some(v)) => *v as i32,
+                _ => return true,
+            };
+            if min_arr.is_null(page_idx) || max_arr.is_null(page_idx) {
+                return true;
+            }
+            let (min, max) = (min_arr.value(page_idx), max_arr.value(page_idx));
+            return Self::compare(min, max, filter_val, op);
+        }
+
+        if let (Some(min_arr), Some(max_arr)) = (
+            mins.as_any().downcast_ref::<Int64Array>(),
+            maxes.as_any().downcast_ref::<Int64Array>(),
+        ) {
+            let filter_val = match value {
+                ScalarValue::Int64(Some(v)) => *v,
+                ScalarValue::Int32(Some(v)) => *v as i64,
+                _ => return true,
+            };
+            if min_arr.is_null(page_idx) || max_arr.is_null(page_idx) {
+                return true;
+            }
+            let (min, max) = (min_arr.value(page_idx), max_arr.value(page_idx));
+            return Self::compare(min, max, filter_val, op);
+        }
+
+        true
+    }
+
+    fn compare<T: Ord>(min: T, max: T, val: T, op: &Operator) -> bool {
+        match op {
+            Operator::Lt => min < val,
+            Operator::LtEq => min <= val,
+            Operator::Gt => max > val,
+            Operator::GtEq => max >= val,
+            Operator::Eq => min <= val && val <= max,
+            Operator::NotEq => !(min == val && max == val),
+            _ => true,
+        }
+    }
+}
diff --git a/plugins/engine-datafusion/jni/src/indexed_table/parquet_bridge.rs b/plugins/engine-datafusion/jni/src/indexed_table/parquet_bridge.rs
new file mode 100644
index 0000000000000..76985ec7c3765
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_table/parquet_bridge.rs
@@ -0,0 +1,267 @@
+/**
+DataFusion parquet bridge — isolates ALL DataFusion parquet-specific API calls.
+
+# Datafusion APIs in use
+
+- `ParquetSource::new()` + `.with_parquet_file_reader_factory()` + `.with_predicate()`
+- `FileScanConfigBuilder::new()` + `.with_file()` + `.with_projection_indices()`
+- `DataSourceExec::from_data_source()`
+- `PartitionedFile::new()` + `.with_extensions()`
+- `ParquetAccessPlan::new_none()` + `.set()`
+- `RowGroupAccess::Selection` / `RowGroupAccess::Scan`
+- `ParquetFileReaderFactory` trait
+- `ParquetFileMetrics`
+- `ObjectStoreUrl::local_filesystem()`
+- `ArrowReaderMetadata::load()` + `ArrowReaderOptions`
+**/
+
+use std::sync::Arc;
+
+use bytes::Bytes;
+use datafusion::arrow::datatypes::SchemaRef;
+use datafusion::common::Result;
+use datafusion::execution::SendableRecordBatchStream;
+use datafusion::parquet::arrow::arrow_reader::{
+    ArrowReaderMetadata, ArrowReaderOptions, RowSelection,
+};
+use datafusion::parquet::arrow::async_reader::AsyncFileReader;
+use datafusion::parquet::file::metadata::ParquetMetaData;
+use datafusion::physical_plan::metrics::ExecutionPlanMetricsSet;
+use datafusion::physical_plan::ExecutionPlan;
+use datafusion_datasource::file_scan_config::FileScanConfigBuilder;
+use datafusion_datasource::source::DataSourceExec;
+use datafusion_datasource::PartitionedFile;
+use datafusion_datasource_parquet::source::ParquetSource;
+use datafusion_datasource_parquet::{
+    ParquetAccessPlan, ParquetFileMetrics, ParquetFileReaderFactory, RowGroupAccess,
+};
+use datafusion_execution::object_store::ObjectStoreUrl;
+use futures::future::BoxFuture;
+use futures::FutureExt;
+use object_store::ObjectStore;
+
+// ── Parquet Metadata Loading ───────────────────────────────────────────
+
+/// Load parquet metadata with page index from a file.
+pub fn load_parquet_metadata(
+    file: &std::fs::File,
+) -> std::result::Result<(SchemaRef, Arc<ParquetMetaData>), String> {
+    let options = ArrowReaderOptions::new().with_page_index(true);
+    let arrow_metadata = ArrowReaderMetadata::load(file, options)
+        .map_err(|e| format!("Failed to load parquet metadata: {}", e))?;
+    let schema = arrow_metadata.schema().clone();
+    let metadata = arrow_metadata.metadata().clone();
+    Ok((schema, metadata))
+}
+
+/// Load parquet metadata without page index (for row count matching).
+pub fn load_parquet_metadata_basic(
+    file: &std::fs::File,
+) -> std::result::Result<Arc<ParquetMetaData>, String> {
+    let options = ArrowReaderOptions::new();
+    let arrow_metadata = ArrowReaderMetadata::load(file, options)
+        .map_err(|e| format!("Failed to load parquet metadata: {}", e))?;
+    Ok(arrow_metadata.metadata().clone())
+}
+
+/// Configuration for creating a per-row-group parquet stream.
+pub struct RowGroupStreamConfig {
+    /// Path to the parquet file.
+    pub file_path: String,
+    /// File size in bytes.
+    pub file_size: u64,
+    /// Full (unprojected) schema.
+    pub full_schema: SchemaRef,
+    /// Cached parquet metadata.
+    pub metadata: Arc<ParquetMetaData>,
+    /// Column projection indices.
+    pub projection: Option<Vec<usize>>,
+    /// Physical predicate for pushdown.
+    pub predicate: Option<Arc<dyn datafusion::physical_expr::PhysicalExpr>>,
+}
+
+/// Create a stream that reads a single row group using RowSelection (v48 strategy).
+///
+/// Predicate pushdown IS safe here — RowSelection is applied during decode,
+/// so the predicate sees only selected rows and indices stay aligned.
+pub fn create_row_selection_stream(
+    config: &RowGroupStreamConfig,
+    rg_index: usize,
+    selection: RowSelection,
+    push_predicate: bool,
+) -> Result<(SendableRecordBatchStream, Arc<dyn ExecutionPlan>)> {
+    let num_rgs = config.metadata.num_row_groups();
+    let mut access_plan = ParquetAccessPlan::new_none(num_rgs);
+    access_plan.set(rg_index, RowGroupAccess::Selection(selection));
+
+    create_stream_with_access_plan(config, access_plan, push_predicate)
+}
+
+/// Create a stream that reads a single row group with full scan (v46 strategy).
+///
+/// Predicate pushdown is NOT safe here — BooleanMask is applied AFTER decode,
+/// so predicate filtering during decode would cause mask offset misalignment.
+pub fn create_full_scan_stream(
+    config: &RowGroupStreamConfig,
+    rg_index: usize,
+) -> Result<(SendableRecordBatchStream, Arc<dyn ExecutionPlan>)> {
+    let num_rgs = config.metadata.num_row_groups();
+    let mut access_plan = ParquetAccessPlan::new_none(num_rgs);
+    access_plan.set(rg_index, RowGroupAccess::Scan);
+
+    create_stream_with_access_plan(config, access_plan, false)
+}
+
+/// Build a DataSourceExec stream for the given access plan.
+///
+/// This is the core DataFusion parquet construction — the ONLY place that
+/// touches ParquetSource, FileScanConfigBuilder, DataSourceExec, etc.
+fn create_stream_with_access_plan(
+    config: &RowGroupStreamConfig,
+    access_plan: ParquetAccessPlan,
+    push_predicate: bool,
+) -> Result<(SendableRecordBatchStream, Arc<dyn ExecutionPlan>)> {
+    let partitioned_file =
+        PartitionedFile::new(config.file_path.clone(), config.file_size)
+            .with_extensions(Arc::new(access_plan));
+
+    let store: Arc<dyn ObjectStore> = Arc::new(object_store::local::LocalFileSystem::new());
+
+    let reader_factory = Arc::new(CachedMetadataReaderFactory::new(
+        store,
+        Arc::clone(&config.metadata),
+    )) as Arc<dyn ParquetFileReaderFactory>;
+
+    let mut parquet_source = ParquetSource::new(config.full_schema.clone())
+        .with_parquet_file_reader_factory(reader_factory)
+        .with_enable_page_index(false);
+
+    if push_predicate {
+        if let Some(ref pred) = config.predicate {
+            parquet_source = parquet_source
+                .with_predicate(Arc::clone(pred))
+                .with_pushdown_filters(true)
+                .with_reorder_filters(true);
+        }
+    }
+
+    let mut config_builder = FileScanConfigBuilder::new(
+        ObjectStoreUrl::local_filesystem(),
+        Arc::new(parquet_source),
+    )
+    .with_file(partitioned_file);
+
+    if let Some(ref proj) = config.projection {
+        config_builder = config_builder.with_projection_indices(Some(proj.clone()))?;
+    }
+
+    let exec: Arc<dyn ExecutionPlan> = DataSourceExec::from_data_source(config_builder.build());
+    let ctx = Arc::new(datafusion::execution::TaskContext::default());
+    let stream = exec.execute(0, ctx)?;
+    Ok((stream, exec))
+}
+
+/// Factory that creates parquet readers with pre-cached metadata.
+///
+/// Avoids re-reading metadata for each row group.
+#[derive(Debug)]
+pub struct CachedMetadataReaderFactory {
+    store: Arc<dyn ObjectStore>,
+    metadata: Arc<ParquetMetaData>,
+}
+
+impl CachedMetadataReaderFactory {
+    pub fn new(store: Arc<dyn ObjectStore>, metadata: Arc<ParquetMetaData>) -> Self {
+        Self { store, metadata }
+    }
+
+    /// Create with page index stripped — avoids "Invalid offset in sparse
+    /// column chunk data" errors when predicate pushdown is enabled.
+    #[allow(dead_code)]
+    pub fn new_without_page_index(
+        store: Arc<dyn ObjectStore>,
+        metadata: Arc<ParquetMetaData>,
+    ) -> Self {
+        use datafusion::parquet::file::metadata::ParquetMetaDataBuilder;
+        let stripped = ParquetMetaDataBuilder::new_from_metadata((*metadata).clone())
+            .set_column_index(None)
+            .set_offset_index(None)
+            .build();
+        Self {
+            store,
+            metadata: Arc::new(stripped),
+        }
+    }
+}
+
+impl ParquetFileReaderFactory for CachedMetadataReaderFactory {
+    fn create_reader(
+        &self,
+        partition_index: usize,
+        file: PartitionedFile,
+        _metadata_size_hint: Option<usize>,
+        metrics: &ExecutionPlanMetricsSet,
+    ) -> datafusion_common::Result<Box<dyn AsyncFileReader + Send>> {
+        let file_metrics = ParquetFileMetrics::new(
+            partition_index,
+            file.object_meta.location.as_ref(),
+            metrics,
+        );
+        Ok(Box::new(CachedMetadataReader {
+            store: Arc::clone(&self.store),
+            location: file.object_meta.location.clone(),
+            metadata: Arc::clone(&self.metadata),
+            metrics: file_metrics,
+        }))
+    }
+}
+
+struct CachedMetadataReader {
+    store: Arc<dyn ObjectStore>,
+    location: object_store::path::Path,
+    metadata: Arc<ParquetMetaData>,
+    metrics: ParquetFileMetrics,
+}
+
+impl AsyncFileReader for CachedMetadataReader {
+    fn get_bytes(
+        &mut self,
+        range: std::ops::Range<u64>,
+    ) -> BoxFuture<'_, datafusion::parquet::errors::Result<Bytes>> {
+        self.metrics.bytes_scanned.add((range.end - range.start) as usize);
+        let store = Arc::clone(&self.store);
+        let location = self.location.clone();
+        async move {
+            store
+                .get_range(&location, range)
+                .await
+                .map_err(|e| datafusion::parquet::errors::ParquetError::External(Box::new(e)))
+        }
+        .boxed()
+    }
+
+    fn get_byte_ranges(
+        &mut self,
+        ranges: Vec<std::ops::Range<u64>>,
+    ) -> BoxFuture<'_, datafusion::parquet::errors::Result<Vec<Bytes>>> {
+        let total: u64 = ranges.iter().map(|r| r.end - r.start).sum();
+        self.metrics.bytes_scanned.add(total as usize);
+        let store = Arc::clone(&self.store);
+        let location = self.location.clone();
+        async move {
+            store
+                .get_ranges(&location, &ranges)
+                .await
+                .map_err(|e| datafusion::parquet::errors::ParquetError::External(Box::new(e)))
+        }
+        .boxed()
+    }
+
+    fn get_metadata(
+        &mut self,
+        _options: Option<&ArrowReaderOptions>,
+    ) -> BoxFuture<'_, datafusion::parquet::errors::Result<Arc<ParquetMetaData>>> {
+        let metadata = Arc::clone(&self.metadata);
+        async move { Ok(metadata) }.boxed()
+    }
+}
diff --git a/plugins/engine-datafusion/jni/src/indexed_table/partitioning.rs b/plugins/engine-datafusion/jni/src/indexed_table/partitioning.rs
new file mode 100644
index 0000000000000..c9401f7c57e62
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_table/partitioning.rs
@@ -0,0 +1,154 @@
+/**
+Partition assignment for distributing row groups across DataFusion partitions.
+
+Same as DataFusion's `repartition_evenly_by_size` model: flatten all row groups
+across all segments, iterate through sequentially, cut a new partition when accumulated
+rows exceed `ceil(total_rows / num_partitions)`.
+
+A single partition may span multiple segments — each segment's RGs become
+a separate `SegmentChunk`.
+
+Reference :  https://github.com/apache/datafusion/blob/49776a65e423890a3eefea8729ba67511fbf0ee4/datafusion/datasource/src/file_groups.rs#L204
+**/
+use super::stream::RowGroupInfo;
+
+/**
+One contiguous chunk of row groups within a single segment.
+**/
+#[derive(Debug, Clone)]
+pub struct SegmentChunk {
+    /// Index into the segments array.
+    pub segment_idx: usize,
+    /// Minimum doc ID (inclusive) for this chunk.
+    pub doc_min: i32,
+    /// Maximum doc ID (exclusive) for this chunk.
+    pub doc_max: i32,
+    /// Row group indices within this segment.
+    pub row_group_indices: Vec<usize>,
+}
+
+/**
+A partition which can span multiple segments.
+**/
+#[derive(Debug, Clone)]
+pub struct PartitionAssignment {
+    pub chunks: Vec<SegmentChunk>,
+}
+
+/**
+Info about a segment needed for partition assignment.
+**/
+pub struct SegmentLayout {
+    pub row_groups: Vec<RowGroupInfo>,
+}
+
+/**
+Compute partition assignments aligned to row group boundaries.
+
+Partitions MUST align to RG boundaries because:
+1. Splitting mid-RG causes duplicate processing
+2. Row indices within a RG are contiguous `[0, num_rows)`
+3. Doc IDs map 1:1 to row indices within each segment's parquet file
+**/
+pub fn compute_assignments(
+    segments: &[SegmentLayout],
+    num_partitions: usize,
+) -> Vec<PartitionAssignment> {
+    struct RGEntry {
+        segment_idx: usize,
+        rg_index: usize,
+        first_row: i64,
+        num_rows: i64,
+    }
+
+    let all_rgs: Vec<RGEntry> = segments
+        .iter()
+        .enumerate()
+        .flat_map(|(seg_idx, seg)| {
+            seg.row_groups.iter().map(move |rg| RGEntry {
+                segment_idx: seg_idx,
+                rg_index: rg.index,
+                first_row: rg.first_row,
+                num_rows: rg.num_rows,
+            })
+        })
+        .collect();
+
+    if all_rgs.is_empty() {
+        return vec![];
+    }
+
+    let total_rows: i64 = all_rgs.iter().map(|rg| rg.num_rows).sum();
+    let rows_per_partition = (total_rows as f64 / num_partitions as f64).ceil() as i64;
+
+    let mut assignments: Vec<PartitionAssignment> = Vec::new();
+    let mut current_chunks: Vec<SegmentChunk> = Vec::new();
+    let mut current_rows: i64 = 0;
+
+    let mut chunk_seg: Option<usize> = None;
+    let mut chunk_rg_indices: Vec<usize> = Vec::new();
+    let mut chunk_doc_min: i32 = 0;
+    let mut chunk_doc_max: i32 = 0;
+
+    for (i, rg) in all_rgs.iter().enumerate() {
+        // Flush in-progress chunk if segment changed
+        if chunk_seg.is_some() && chunk_seg != Some(rg.segment_idx) {
+            if !chunk_rg_indices.is_empty() {
+                current_chunks.push(SegmentChunk {
+                    segment_idx: chunk_seg.unwrap(),
+                    doc_min: chunk_doc_min,
+                    doc_max: chunk_doc_max,
+                    row_group_indices: chunk_rg_indices.clone(),
+                });
+                chunk_rg_indices.clear();
+            }
+        }
+
+        if chunk_seg != Some(rg.segment_idx) {
+            chunk_seg = Some(rg.segment_idx);
+            chunk_doc_min = rg.first_row as i32;
+        }
+
+        chunk_rg_indices.push(rg.rg_index);
+        chunk_doc_max = (rg.first_row + rg.num_rows) as i32;
+        current_rows += rg.num_rows;
+
+        let is_last = i == all_rgs.len() - 1;
+
+        if current_rows >= rows_per_partition
+            && assignments.len() < num_partitions - 1
+            && !is_last
+        {
+            current_chunks.push(SegmentChunk {
+                segment_idx: chunk_seg.unwrap(),
+                doc_min: chunk_doc_min,
+                doc_max: chunk_doc_max,
+                row_group_indices: chunk_rg_indices.clone(),
+            });
+            chunk_rg_indices.clear();
+            chunk_doc_min = chunk_doc_max;
+
+            assignments.push(PartitionAssignment {
+                chunks: std::mem::take(&mut current_chunks),
+            });
+            current_rows = 0;
+        }
+    }
+
+    // Flush remaining
+    if !chunk_rg_indices.is_empty() {
+        current_chunks.push(SegmentChunk {
+            segment_idx: chunk_seg.unwrap(),
+            doc_min: chunk_doc_min,
+            doc_max: chunk_doc_max,
+            row_group_indices: chunk_rg_indices,
+        });
+    }
+    if !current_chunks.is_empty() {
+        assignments.push(PartitionAssignment {
+            chunks: current_chunks,
+        });
+    }
+
+    assignments
+}
diff --git a/plugins/engine-datafusion/jni/src/indexed_table/stream.rs b/plugins/engine-datafusion/jni/src/indexed_table/stream.rs
new file mode 100644
index 0000000000000..e60242ed7c3c5
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_table/stream.rs
@@ -0,0 +1,703 @@
+/**
+Streaming execution for indexed parquet reads. This is mainly the scan logic for one partition -
+particularily one segment chunk of the partition.
+
+Processes row groups one at a time, applying page pruning and either
+RowSelection (v48) or BooleanMask (v46) based on selectivity.
+
+Prefetch : While processing the current row group's parquet data, we prefetch doc IDs
+for the next row group in a background task. This overlaps index query I/O with
+parquet I/O for better throughput.
+
+All DataFusion parquet-specific API calls (ParquetSource, FileScanConfigBuilder,
+DataSourceExec, etc.) are delegated to `parquet_bridge`. This file only uses
+stable Arrow types and the bridge's public API.
+**/
+
+use std::any::Any;
+use std::path::PathBuf;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+
+use datafusion::arrow::array::{Array, BooleanArray};
+use datafusion::arrow::compute::filter_record_batch;
+use datafusion::arrow::datatypes::SchemaRef;
+use datafusion::arrow::record_batch::RecordBatch;
+use datafusion::common::Result;
+use datafusion::execution::SendableRecordBatchStream;
+use datafusion::logical_expr::Expr;
+use datafusion::parquet::arrow::arrow_reader::{RowSelection, RowSelector};
+use datafusion::parquet::file::metadata::ParquetMetaData;
+use datafusion::physical_plan::metrics::{ExecutionPlanMetricsSet, MetricsSet};
+use datafusion::physical_plan::{
+    DisplayAs, DisplayFormatType, ExecutionPlan, PlanProperties, RecordBatchStream,
+};
+use datafusion_common::DataFusionError;
+use futures::{Future, Stream};
+use tokio::sync::oneshot;
+
+use super::index::{BitsetMode, RowGroupDocsCollector};
+use super::metrics::StreamMetrics;
+use super::page_pruner::PagePruner;
+use super::parquet_bridge::{self, RowGroupStreamConfig};
+
+/// Row group metadata.
+#[derive(Debug, Clone)]
+pub struct RowGroupInfo {
+    pub index: usize,
+    pub first_row: i64,
+    pub num_rows: i64,
+}
+
+/// Strategy for filtering rows within a row group.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum FilterStrategy {
+    /// RowSelection during decode — best for <3% selectivity.
+    RowSelection,
+    /// BooleanArray mask after decode — best for ≥3% selectivity.
+    BooleanMask,
+}
+
+impl FilterStrategy {
+    /// Choose strategy based on selectivity within a row group.
+    pub fn choose(num_selected: usize, total_rows: i64) -> Self {
+        let selectivity = num_selected as f64 / total_rows as f64;
+        if selectivity < 0.03 {
+            FilterStrategy::RowSelection
+        } else {
+            FilterStrategy::BooleanMask
+        }
+    }
+}
+
+/// Convert sorted offsets to RowSelection.
+pub fn offsets_to_row_selection(offsets: &[u64], num_rows: i64) -> RowSelection {
+    if offsets.is_empty() {
+        return RowSelection::from(vec![RowSelector::skip(num_rows as usize)]);
+    }
+    let mut selectors = Vec::new();
+    let mut pos = 0u64;
+    let mut i = 0;
+    while i < offsets.len() {
+        let start = offsets[i];
+        if start > pos {
+            selectors.push(RowSelector::skip((start - pos) as usize));
+        }
+        let mut run = 1usize;
+        while i + run < offsets.len() && offsets[i + run] == start + run as u64 {
+            run += 1;
+        }
+        selectors.push(RowSelector::select(run));
+        pos = start + run as u64;
+        i += run;
+    }
+    if pos < num_rows as u64 {
+        selectors.push(RowSelector::skip((num_rows as u64 - pos) as usize));
+    }
+    RowSelection::from(selectors)
+}
+
+fn build_mask(offsets: &[u64], num_rows: i64) -> BooleanArray {
+    let mut mask = vec![false; num_rows as usize];
+    for &offset in offsets {
+        if (offset as i64) < num_rows {
+            mask[offset as usize] = true;
+        }
+    }
+    BooleanArray::from(mask)
+}
+
+// ── Prefetched Row Group Data ──────────────────────────────────────────
+
+struct PrefetchedRowGroup {
+    rg: RowGroupInfo,
+    offsets: Vec<u64>,
+    /// Time spent in Lucene collect + page pruning (nanoseconds).
+    lucene_nanos: u64,
+}
+
+type PrefetchResult = Result<Option<PrefetchedRowGroup>, String>;
+type PrefetchHandle = oneshot::Receiver<PrefetchResult>;
+
+/// Reads doc IDs from a single `SegmentCollector` with async prefetching.
+///
+/// Each row group: collect bitset, apply page pruning (AND or OR mode),
+/// then hand off offsets for parquet reading.
+struct IndexReader {
+    collector: Arc<dyn RowGroupDocsCollector>,
+    row_groups: Vec<RowGroupInfo>,
+    current_rg_idx: usize,
+    page_pruner: Arc<PagePruner>,
+    bitset_mode: BitsetMode,
+    pending_prefetch: Option<PrefetchHandle>,
+    cached_result: Option<PrefetchResult>,
+    doc_range: Option<(i32, i32)>,
+}
+
+impl IndexReader {
+    fn new(
+        collector: Arc<dyn RowGroupDocsCollector>,
+        row_groups: Vec<RowGroupInfo>,
+        page_pruner: PagePruner,
+        bitset_mode: BitsetMode,
+        doc_range: Option<(i32, i32)>,
+    ) -> Self {
+        Self {
+            collector,
+            row_groups,
+            current_rg_idx: 0,
+            page_pruner: Arc::new(page_pruner),
+            bitset_mode,
+            pending_prefetch: None,
+            cached_result: None,
+            doc_range,
+        }
+    }
+
+    /// Fetch doc IDs for a specific row group.
+    fn fetch_row_group(
+        collector: &Arc<dyn RowGroupDocsCollector>,
+        page_pruner: &PagePruner,
+        bitset_mode: BitsetMode,
+        row_groups: &[RowGroupInfo],
+        rg_idx: usize,
+        doc_range: Option<(i32, i32)>,
+    ) -> Result<Option<PrefetchedRowGroup>, String> {
+        if rg_idx >= row_groups.len() {
+            return Ok(None);
+        }
+
+        let rg = row_groups[rg_idx].clone();
+        let rg_start = rg.first_row as i32;
+        let rg_end = (rg.first_row + rg.num_rows) as i32;
+
+        let mut min_doc = rg_start;
+        let mut max_doc = rg_end;
+
+        if let Some((range_min, range_max)) = doc_range {
+            min_doc = min_doc.max(range_min);
+            max_doc = max_doc.min(range_max);
+            if min_doc >= max_doc {
+                return Ok(None);
+            }
+        }
+
+        let t_lucene = std::time::Instant::now();
+
+        // Collect bitset from the single collector
+        let bitset = collector.collect(min_doc, max_doc)?;
+
+        eprintln!("[INDEXED-DEBUG] fetch_row_group rg={}: min_doc={}, max_doc={}, bitset_words={}, bitset_popcount={}", 
+            rg_idx, min_doc, max_doc, bitset.len(),
+            bitset.iter().map(|w| w.count_ones() as usize).sum::<usize>());
+
+        // Expand bitset to doc IDs
+        let mut raw_ids: Vec<i64> = Vec::new();
+        for (word_idx, &word) in bitset.iter().enumerate() {
+            if word == 0 {
+                continue;
+            }
+            let base = min_doc as i64 + (word_idx as i64 * 64);
+            for bit in 0..64 {
+                if (word >> bit) & 1 == 1 {
+                    let doc_id = base + bit;
+                    if doc_id < max_doc as i64 {
+                        raw_ids.push(doc_id);
+                    }
+                }
+            }
+        }
+
+        // bitset from java , parquet each rg - access plan - page stats
+        // Apply page pruning based on BitsetMode
+
+        //
+        let final_ids = match bitset_mode {
+            BitsetMode::And => {
+                // Intersect: row must be in bitset AND in matching pages
+                page_pruner.filter_row_ids(rg.index, &raw_ids, rg.first_row)
+            }
+            BitsetMode::Or => {
+                // Union: row must be in bitset OR in matching pages
+                let candidate_ids =
+                    page_pruner.candidate_row_ids(rg.index, rg.first_row, rg.num_rows);
+                sorted_union(&raw_ids, &candidate_ids)
+            }
+        };
+
+        if final_ids.is_empty() {
+            return Ok(None);
+        }
+
+        let lucene_nanos = t_lucene.elapsed().as_nanos() as u64;
+
+        let offsets: Vec<u64> = final_ids
+            .iter()
+            .map(|&id| (id - rg.first_row) as u64)
+            .collect();
+
+        Ok(Some(PrefetchedRowGroup { rg, offsets, lucene_nanos }))
+    }
+
+    fn start_prefetch(&mut self, rg_idx: usize) {
+        if rg_idx >= self.row_groups.len() {
+            return;
+        }
+
+        let collector = Arc::clone(&self.collector);
+        let page_pruner = Arc::clone(&self.page_pruner);
+        let bitset_mode = self.bitset_mode;
+        let row_groups = self.row_groups.clone();
+        let doc_range = self.doc_range;
+
+        let (tx, rx) = oneshot::channel();
+
+        eprintln!("[INDEXED-DEBUG] start_prefetch rg={}: thread={:?}, is_tokio={}", 
+            rg_idx, std::thread::current().name(), tokio::runtime::Handle::try_current().is_ok());
+
+        tokio::task::spawn_blocking(move || {
+            eprintln!("[INDEXED-DEBUG] spawn_blocking running: thread={:?}, is_tokio={}", 
+                std::thread::current().name(), tokio::runtime::Handle::try_current().is_ok());
+            let result = Self::fetch_row_group(
+                &collector,
+                &page_pruner,
+                bitset_mode,
+                &row_groups,
+                rg_idx,
+                doc_range,
+            );
+            let _ = tx.send(result);
+        });
+
+        self.pending_prefetch = Some(rx);
+    }
+
+    fn poll_next_row_group(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Option<PrefetchedRowGroup>, DataFusionError>> {
+        loop {
+            if self.current_rg_idx >= self.row_groups.len() {
+                return Poll::Ready(Ok(None));
+            }
+
+            if let Some(result) = self.cached_result.take() {
+                self.current_rg_idx += 1;
+                self.start_prefetch(self.current_rg_idx);
+
+                match result {
+                    Ok(Some(prefetched)) => return Poll::Ready(Ok(Some(prefetched))),
+                    Ok(None) => continue,
+                    Err(e) => return Poll::Ready(Err(DataFusionError::External(e.into()))),
+                }
+            }
+
+            if let Some(ref mut rx) = self.pending_prefetch {
+                match Pin::new(rx).poll(cx) {
+                    Poll::Ready(Ok(result)) => {
+                        self.pending_prefetch = None;
+                        self.cached_result = Some(result);
+                        continue;
+                    }
+                    Poll::Ready(Err(_)) => {
+                        self.pending_prefetch = None;
+                        self.start_prefetch(self.current_rg_idx);
+                        return Poll::Pending;
+                    }
+                    Poll::Pending => return Poll::Pending,
+                }
+            }
+
+            self.start_prefetch(self.current_rg_idx);
+            return Poll::Pending;
+        }
+    }
+
+    fn init_prefetch(&mut self) {
+        self.start_prefetch(0);
+    }
+}
+
+/// Merge two sorted `i64` slices into a sorted, deduplicated vec.
+fn sorted_union(a: &[i64], b: &[i64]) -> Vec<i64> {
+    let mut result = Vec::with_capacity(a.len() + b.len());
+    let (mut i, mut j) = (0, 0);
+    while i < a.len() && j < b.len() {
+        match a[i].cmp(&b[j]) {
+            std::cmp::Ordering::Less => {
+                result.push(a[i]);
+                i += 1;
+            }
+            std::cmp::Ordering::Greater => {
+                result.push(b[j]);
+                j += 1;
+            }
+            std::cmp::Ordering::Equal => {
+                result.push(a[i]);
+                i += 1;
+                j += 1;
+            }
+        }
+    }
+    result.extend_from_slice(&a[i..]);
+    result.extend_from_slice(&b[j..]);
+    result
+}
+
+/// Execution plan for a single segment's indexed parquet read.
+///
+/// Streams row groups one at a time, applying page pruning and adaptive
+/// RowSelection/BooleanMask strategy per row group.
+pub struct IndexedExec {
+    pub(crate) schema: SchemaRef,
+    pub(crate) full_schema: SchemaRef,
+    pub(crate) file_path: PathBuf,
+    pub(crate) file_size: u64,
+    pub(crate) row_groups: Vec<RowGroupInfo>,
+    pub(crate) projection: Option<Vec<usize>>,
+    pub(crate) properties: PlanProperties,
+    pub(crate) metadata: Arc<ParquetMetaData>,
+    pub(crate) filters: Vec<Expr>,
+    pub(crate) predicate: Option<Arc<dyn datafusion::physical_expr::PhysicalExpr>>,
+    /// Pre-created collector for this segment (from ShardSearcher).
+    pub(crate) collector: std::sync::Mutex<Option<Arc<dyn RowGroupDocsCollector>>>,
+    /// How the bitset relates to page pruner filters.
+    pub(crate) bitset_mode: BitsetMode,
+    /// Optional doc ID range restriction `[min, max)`.
+    pub(crate) doc_range: Option<(i32, i32)>,
+    pub(crate) metrics: ExecutionPlanMetricsSet,
+    pub(crate) stream_metrics: StreamMetrics,
+    pub(crate) force_pushdown: Option<bool>,
+    pub(crate) force_strategy: Option<FilterStrategy>,
+}
+
+impl std::fmt::Debug for IndexedExec {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("IndexedExec")
+            .field("row_groups", &self.row_groups.len())
+            .field("filters", &self.filters.len())
+            .field("has_predicate", &self.predicate.is_some())
+            .field("bitset_mode", &self.bitset_mode)
+            .finish()
+    }
+}
+
+impl DisplayAs for IndexedExec {
+    fn fmt_as(&self, _t: DisplayFormatType, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let total_rows: i64 = self.row_groups.iter().map(|rg| rg.num_rows).sum();
+        let doc_range_str = match self.doc_range {
+            Some((min, max)) => format!(", doc_range=[{}, {})", min, max),
+            None => String::new(),
+        };
+        write!(
+            f,
+            "IndexedExec: rg={}, total_rows={}, filters={}, predicate={}, mode={:?}{}",
+            self.row_groups.len(),
+            total_rows,
+            self.filters.len(),
+            self.predicate.is_some(),
+            self.bitset_mode,
+            doc_range_str,
+        )
+    }
+}
+
+impl ExecutionPlan for IndexedExec {
+    fn name(&self) -> &str { "IndexedExec" }
+    fn as_any(&self) -> &dyn Any { self }
+    fn schema(&self) -> SchemaRef { self.schema.clone() }
+    fn properties(&self) -> &PlanProperties { &self.properties }
+    fn children(&self) -> Vec<&Arc<dyn ExecutionPlan>> { vec![] }
+
+    fn with_new_children(
+        self: Arc<Self>,
+        _children: Vec<Arc<dyn ExecutionPlan>>,
+    ) -> Result<Arc<dyn ExecutionPlan>> {
+        Ok(self)
+    }
+
+    fn metrics(&self) -> Option<MetricsSet> {
+        Some(self.metrics.clone_inner())
+    }
+
+    fn execute(
+        &self,
+        _partition: usize,
+        _context: Arc<datafusion::execution::TaskContext>,
+    ) -> Result<SendableRecordBatchStream> {
+        eprintln!("[INDEXED-DEBUG] IndexedExec.execute: thread={:?}, is_tokio={}", 
+            std::thread::current().name(), tokio::runtime::Handle::try_current().is_ok());
+        let collector = {
+            let mut guard = self.collector.lock().unwrap();
+            guard.take().ok_or_else(|| {
+                DataFusionError::Internal("IndexedExec: collector already consumed".to_string())
+            })?
+        };
+
+        let page_pruner =
+            PagePruner::new(&self.full_schema, Arc::clone(&self.metadata), &self.filters);
+
+        let index_reader = IndexReader::new(
+            collector,
+            self.row_groups.clone(),
+            page_pruner,
+            self.bitset_mode,
+            self.doc_range,
+        );
+
+        Ok(Box::pin(IndexedStream::new(
+            self.schema.clone(),
+            self.full_schema.clone(),
+            self.file_path.clone(),
+            self.file_size,
+            index_reader,
+            self.projection.clone(),
+            Arc::clone(&self.metadata),
+            self.predicate.clone(),
+            self.stream_metrics.clone(),
+            self.force_pushdown,
+            self.force_strategy,
+        )))
+    }
+}
+
+struct IndexedStream {
+    schema: SchemaRef,
+    full_schema: SchemaRef,
+    file_path: PathBuf,
+    file_size: u64,
+    index_reader: IndexReader,
+    projection: Option<Vec<usize>>,
+    current_stream: Option<SendableRecordBatchStream>,
+    current_inner_plan: Option<Arc<dyn ExecutionPlan>>,
+    current_mask: Option<BooleanArray>,
+    mask_offset: usize,
+    finished: bool,
+    metadata: Arc<ParquetMetaData>,
+    predicate: Option<Arc<dyn datafusion::physical_expr::PhysicalExpr>>,
+    initialized: bool,
+    metrics: StreamMetrics,
+    force_pushdown: Option<bool>,
+    force_strategy: Option<FilterStrategy>,
+}
+
+impl IndexedStream {
+    fn new(
+        schema: SchemaRef,
+        full_schema: SchemaRef,
+        file_path: PathBuf,
+        file_size: u64,
+        index_reader: IndexReader,
+        projection: Option<Vec<usize>>,
+        metadata: Arc<ParquetMetaData>,
+        predicate: Option<Arc<dyn datafusion::physical_expr::PhysicalExpr>>,
+        metrics: StreamMetrics,
+        force_pushdown: Option<bool>,
+        force_strategy: Option<FilterStrategy>,
+    ) -> Self {
+        Self {
+            schema,
+            full_schema,
+            file_path,
+            file_size,
+            index_reader,
+            projection,
+            current_stream: None,
+            current_inner_plan: None,
+            current_mask: None,
+            mask_offset: 0,
+            finished: false,
+            metadata,
+            predicate,
+            initialized: false,
+            metrics,
+            force_pushdown,
+            force_strategy,
+        }
+    }
+
+    /// Build the bridge config (shared between v48 and v46 paths).
+    fn bridge_config(&self) -> RowGroupStreamConfig {
+        RowGroupStreamConfig {
+            file_path: self.file_path.to_string_lossy().to_string(),
+            file_size: self.file_size,
+            full_schema: self.full_schema.clone(),
+            metadata: Arc::clone(&self.metadata),
+            projection: self.projection.clone(),
+            predicate: self.predicate.clone(),
+        }
+    }
+
+    /// RowSelection stream (v48) — predicate pushdown is safe here.
+    fn create_row_selection_stream(
+        &self,
+        rg: &RowGroupInfo,
+        offsets: &[u64],
+    ) -> Result<(SendableRecordBatchStream, Arc<dyn ExecutionPlan>)> {
+        let selection = offsets_to_row_selection(offsets, rg.num_rows);
+        let push = self.force_pushdown.unwrap_or(true);
+        parquet_bridge::create_row_selection_stream(&self.bridge_config(), rg.index, selection, push)
+    }
+
+    /// Full scan stream (v46) — predicate pushdown is NOT safe (mask offset misalignment).
+    fn create_full_scan_stream(
+        &self,
+        rg: &RowGroupInfo,
+    ) -> Result<(SendableRecordBatchStream, Arc<dyn ExecutionPlan>)> {
+        parquet_bridge::create_full_scan_stream(&self.bridge_config(), rg.index)
+    }
+}
+
+impl Stream for IndexedStream {
+    type Item = Result<RecordBatch>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        if !self.initialized {
+            eprintln!("[INDEXED-DEBUG] IndexedStream.poll_next init: thread={:?}, is_tokio={}", 
+                std::thread::current().name(), tokio::runtime::Handle::try_current().is_ok());
+            self.index_reader.init_prefetch();
+            self.initialized = true;
+        }
+
+        loop {
+            // Poll current stream
+            if let Some(ref mut stream) = self.current_stream {
+                match Pin::new(stream).poll_next(cx) {
+                    Poll::Ready(Some(Ok(batch))) if batch.num_rows() > 0 => {
+                        if let Some(ref mask) = self.current_mask {
+                            let batch_len = batch.num_rows();
+                            let mask_slice = mask.slice(self.mask_offset, batch_len);
+                            let mask_slice =
+                                mask_slice.as_any().downcast_ref::<BooleanArray>().unwrap();
+                            self.mask_offset += batch_len;
+                            match filter_record_batch(&batch, mask_slice) {
+                                Ok(filtered) if filtered.num_rows() > 0 => {
+                                    if let Some(ref counter) = self.metrics.output_rows {
+                                        counter.add(filtered.num_rows());
+                                    }
+                                    return Poll::Ready(Some(Ok(filtered)));
+                                }
+                                Ok(_) => continue,
+                                Err(e) => {
+                                    return Poll::Ready(Some(Err(DataFusionError::ArrowError(
+                                        Box::new(e),
+                                        None,
+                                    ))));
+                                }
+                            }
+                        } else {
+                            if let Some(ref counter) = self.metrics.output_rows {
+                                counter.add(batch.num_rows());
+                            }
+                            return Poll::Ready(Some(Ok(batch)));
+                        }
+                    }
+                    Poll::Ready(Some(Ok(_))) => continue,
+                    Poll::Ready(Some(Err(e))) => return Poll::Ready(Some(Err(e))),
+                    Poll::Ready(None) => {
+                        // Stream finished — collect inner parquet metrics
+                        if let Some(inner_plan) = self.current_inner_plan.take() {
+                            if let Some(inner_metrics) = inner_plan.metrics() {
+                                if let Some(ref acc) = self.metrics.inner_parquet_metrics {
+                                    if let Ok(mut vec) = acc.lock() {
+                                        vec.push(inner_metrics);
+                                    }
+                                }
+                            }
+                        }
+                        self.current_stream = None;
+                        self.current_mask = None;
+                        self.mask_offset = 0;
+                    }
+                    Poll::Pending => return Poll::Pending,
+                }
+            }
+
+            if self.finished {
+                return Poll::Ready(None);
+            }
+
+            // Poll for next row group
+            match self.index_reader.poll_next_row_group(cx) {
+                Poll::Ready(Ok(Some(prefetched))) => {
+                    let rg = prefetched.rg;
+                    let offsets = prefetched.offsets;
+
+                    // Record Lucene/JNI collect time
+                    if let Some(ref timer) = self.metrics.lucene_time {
+                        timer.add_duration(std::time::Duration::from_nanos(prefetched.lucene_nanos));
+                    }
+
+                    if let Some(ref counter) = self.metrics.rows_matched {
+                        counter.add(offsets.len());
+                    }
+                    if let Some(ref counter) = self.metrics.rg_processed {
+                        counter.add(1);
+                    }
+
+                    let strategy = self
+                        .force_strategy
+                        .unwrap_or_else(|| FilterStrategy::choose(offsets.len(), rg.num_rows));
+
+                    // Time plan creation (parquet bridge setup)
+                    let t_plan = std::time::Instant::now();
+
+                    match strategy {
+                        FilterStrategy::RowSelection => {
+                            if let Some(ref counter) = self.metrics.row_selection_count {
+                                counter.add(1);
+                            }
+
+                            // lucene-f1 or parquet-f2
+                            // prune pages - (lucene-f1 [1] or parquet-f2-page [0])
+                            // row selection
+                            // or parquet-f2-selection
+                            match self.create_row_selection_stream(&rg, &offsets) {
+                                Ok((stream, plan)) => {
+                                    if let Some(ref timer) = self.metrics.parquet_time {
+                                        timer.add_duration(t_plan.elapsed());
+                                    }
+                                    self.current_stream = Some(stream);
+                                    self.current_inner_plan = Some(plan);
+                                    self.current_mask = None;
+                                }
+                                Err(e) => return Poll::Ready(Some(Err(e))),
+                            }
+                        }
+                        // (bitset or parquet-f2-field matches a) and (bitset2 and parquet-f2-field matches a)
+                        FilterStrategy::BooleanMask => {
+                            if let Some(ref counter) = self.metrics.boolean_mask_count {
+                                counter.add(1);
+                            }
+                            match self.create_full_scan_stream(&rg) {
+                                Ok((stream, plan)) => {
+                                    if let Some(ref timer) = self.metrics.parquet_time {
+                                        timer.add_duration(t_plan.elapsed());
+                                    }
+                                    self.current_stream = Some(stream);
+                                    self.current_inner_plan = Some(plan);
+                                    self.current_mask = Some(build_mask(&offsets, rg.num_rows));
+                                    self.mask_offset = 0;
+                                }
+                                Err(e) => return Poll::Ready(Some(Err(e))),
+                            }
+                        }
+                    }
+                }
+                Poll::Ready(Ok(None)) => {
+                    self.finished = true;
+                    return Poll::Ready(None);
+                }
+                Poll::Ready(Err(e)) => return Poll::Ready(Some(Err(e))),
+                Poll::Pending => return Poll::Pending,
+            }
+        }
+    }
+}
+
+impl RecordBatchStream for IndexedStream {
+    fn schema(&self) -> SchemaRef {
+        self.schema.clone()
+    }
+}
diff --git a/plugins/engine-datafusion/jni/src/indexed_table/table_provider.rs b/plugins/engine-datafusion/jni/src/indexed_table/table_provider.rs
new file mode 100644
index 0000000000000..07bb0421e8214
--- /dev/null
+++ b/plugins/engine-datafusion/jni/src/indexed_table/table_provider.rs
@@ -0,0 +1,510 @@
+/**
+`IndexedTableProvider` — the main entry point for indexed parquet queries.
+
+Index-agnostic: receives a single `ShardSearcher` (Java handles boolean tree
+logic and produces one combined bitset) TODO : support multiple searchers / bitsets
+plus a `BitsetMode` that controls how
+the bitset relates to page pruner filters (AND = intersect, OR = union).
+
+Query Client :
+  1. Creates a ShardSearcher (Java walks boolean tree → single Weight)
+  2. Builds SegmentFileInfo list (segment -> parquet mapping)
+  3. Passes both + BitsetMode to IndexedTableProvider
+
+IndexedTableProvider::scan() →
+  1. Compute partition assignments (RGs across segments) - Each partition can contain one or more
+segments but the partitions respects row group boundaries.
+  2. Return QueryShardExec (carries the searcher + bitset_mode) - Has the logic to execute the shard
+query with N partitions
+
+QueryShardExec::execute(partition) →
+  For each SegmentChunk in assignment [ IndexedExec has the logic ]
+    1. ShardSearcher.collector(segment, doc_range) → SegmentCollector
+    2. IndexedExec with that collector + bitset_mode
+    3. Per RG: collect bitset → page prune (AND/OR) → read parquet
+    4. Chain streams if multiple chunks
+**/
+
+use std::any::Any;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use datafusion::arrow::datatypes::{DataType, Field, Schema, SchemaRef};
+use datafusion::catalog::Session;
+use datafusion::common::{DFSchema, Result};
+use datafusion::datasource::{TableProvider, TableType};
+use datafusion::logical_expr::{Expr, Operator, TableProviderFilterPushDown};
+use datafusion::parquet::file::metadata::ParquetMetaData;
+use datafusion::physical_expr::create_physical_expr;
+use datafusion::physical_expr::EquivalenceProperties;
+use datafusion::physical_plan::metrics::{ExecutionPlanMetricsSet, MetricsSet};
+use datafusion::physical_plan::stream::RecordBatchStreamAdapter;
+use datafusion::physical_plan::{
+    DisplayAs, DisplayFormatType, ExecutionPlan, Partitioning, PlanProperties,
+};
+use datafusion_common::DataFusionError;
+use futures::StreamExt;
+
+use super::index::{BitsetMode, ShardSearcher};
+use super::metrics::PartitionMetrics;
+use super::partitioning::{compute_assignments, PartitionAssignment, SegmentLayout};
+use super::stream::{FilterStrategy, IndexedExec, RowGroupInfo};
+
+/// Coerce Binary columns to Utf8 for better query compatibility.
+pub fn coerce_binary_to_string(schema: SchemaRef) -> SchemaRef {
+    let fields: Vec<Field> = schema
+        .fields()
+        .iter()
+        .map(|f| {
+            if matches!(f.data_type(), DataType::Binary | DataType::LargeBinary) {
+                Field::new(f.name(), DataType::Utf8, f.is_nullable())
+                    .with_metadata(f.metadata().clone())
+            } else {
+                f.as_ref().clone()
+            }
+        })
+        .collect();
+    Arc::new(Schema::new(fields))
+}
+
+/// Info about a segment and its corresponding parquet file.
+#[derive(Debug, Clone)]
+pub struct SegmentFileInfo {
+    pub segment_ord: i32,
+    pub max_doc: i64,
+    pub parquet_path: PathBuf,
+    pub parquet_size: u64,
+    pub row_groups: Vec<RowGroupInfo>,
+    pub metadata: Arc<ParquetMetaData>,
+}
+
+/// Configuration for an indexed table.
+pub struct IndexedTableConfig {
+    // The single searcher for this query (Java handles boolean tree → one bitset). TODO : support multi searchers
+    pub searcher: Arc<dyn ShardSearcher>,
+    // How the bitset relates to parquet filters (AND = intersect, OR = union).
+    pub bitset_mode: BitsetMode,
+    // Segment-to-parquet mapping with metadata.
+    pub segments: Vec<SegmentFileInfo>,
+    pub schema: SchemaRef,
+    // Number of partitions (None = use segment count).
+    pub num_partitions: Option<usize>,
+    // Force predicate pushdown on/off (None = adaptive).
+    pub force_pushdown: Option<bool>,
+    // Force filter strategy (None = adaptive).
+    pub force_strategy: Option<FilterStrategy>,
+}
+
+impl IndexedTableConfig {
+    /// Create a new config with default AND mode.
+    pub fn new(
+        searcher: Arc<dyn ShardSearcher>,
+        segments: Vec<SegmentFileInfo>,
+        schema: SchemaRef,
+    ) -> Self {
+        Self {
+            searcher,
+            bitset_mode: BitsetMode::default(),
+            segments,
+            schema,
+            num_partitions: None,
+            force_pushdown: None,
+            force_strategy: None,
+        }
+    }
+
+    /// Builder: set bitset mode.
+    pub fn with_bitset_mode(mut self, mode: BitsetMode) -> Self {
+        self.bitset_mode = mode;
+        self
+    }
+
+    /// Builder: set number of partitions.
+    pub fn with_partitions(mut self, n: usize) -> Self {
+        self.num_partitions = Some(n.max(1));
+        self
+    }
+
+    /// Builder: force pushdown on/off.
+    pub fn with_pushdown(mut self, pushdown: Option<bool>) -> Self {
+        self.force_pushdown = pushdown;
+        self
+    }
+
+    /// Builder: force filter strategy.
+    pub fn with_strategy(mut self, strategy: Option<FilterStrategy>) -> Self {
+        self.force_strategy = strategy;
+        self
+    }
+}
+
+/// Multi-segment TableProvider with configurable partitioning.
+///
+/// This is Index-agnostic — only knows about a `ShardSearcher`, `BitsetMode`, segments,
+/// and parquet files.
+pub struct IndexedTableProvider {
+    schema: SchemaRef,
+    segments: Vec<SegmentFileInfo>,
+    searcher: Arc<dyn ShardSearcher>,
+    bitset_mode: BitsetMode,
+    num_partitions: Option<usize>,
+    force_pushdown: Option<bool>,
+    force_strategy: Option<FilterStrategy>,
+}
+
+impl std::fmt::Debug for IndexedTableProvider {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("IndexedTableProvider")
+            .field("segments", &self.segments.len())
+            .field("bitset_mode", &self.bitset_mode)
+            .finish()
+    }
+}
+
+impl IndexedTableProvider {
+    /// Create from config.
+    pub fn try_new(config: IndexedTableConfig) -> Result<Self, DataFusionError> {
+        if config.segments.is_empty() {
+            return Err(DataFusionError::External("No segments provided".into()));
+        }
+
+        Ok(Self {
+            schema: config.schema,
+            segments: config.segments,
+            searcher: config.searcher,
+            bitset_mode: config.bitset_mode,
+            num_partitions: config.num_partitions,
+            force_pushdown: config.force_pushdown,
+            force_strategy: config.force_strategy,
+        })
+    }
+
+    pub fn with_partitions(mut self, n: usize) -> Self {
+        self.num_partitions = Some(n.max(1));
+        self
+    }
+
+    pub fn with_pushdown(mut self, pushdown: Option<bool>) -> Self {
+        self.force_pushdown = pushdown;
+        self
+    }
+
+    // Builder: force filter strategy. Used for testing
+    pub fn with_strategy(mut self, strategy: Option<FilterStrategy>) -> Self {
+        self.force_strategy = strategy;
+        self
+    }
+
+    pub fn num_partitions(&self) -> usize {
+        self.num_partitions.unwrap_or(self.segments.len())
+    }
+
+    pub fn num_segments(&self) -> usize {
+        self.segments.len()
+    }
+
+    pub fn total_rows(&self) -> i64 {
+        self.segments
+            .iter()
+            .flat_map(|s| &s.row_groups)
+            .map(|rg| rg.num_rows)
+            .sum()
+    }
+
+    pub fn total_row_groups(&self) -> usize {
+        self.segments.iter().map(|s| s.row_groups.len()).sum()
+    }
+}
+
+#[async_trait]
+impl TableProvider for IndexedTableProvider {
+    fn as_any(&self) -> &dyn Any { self }
+    fn schema(&self) -> SchemaRef { self.schema.clone() }
+    fn table_type(&self) -> TableType { TableType::Base }
+
+    async fn scan(
+        &self,
+        state: &dyn Session,
+        projection: Option<&Vec<usize>>,
+        filters: &[Expr],
+        _limit: Option<usize>,
+    ) -> Result<Arc<dyn ExecutionPlan>> {
+        let output_schema = match projection {
+            Some(proj) => Arc::new(Schema::new(
+                proj.iter()
+                    .map(|&i| self.schema.field(i).clone())
+                    .collect::<Vec<_>>(),
+            )),
+            None => self.schema.clone(),
+        };
+
+        let predicate = if !filters.is_empty() {
+            let combined = filters
+                .iter()
+                .skip(1)
+                .fold(filters[0].clone(), |acc, f| acc.and(f.clone()));
+            let df_schema = DFSchema::try_from(self.schema.as_ref().clone())?;
+            create_physical_expr(&combined, &df_schema, state.execution_props()).ok()
+        } else {
+            None
+        };
+
+        let num_partitions = self.num_partitions();
+        let segInfo: Vec<SegmentLayout> = self
+            .segments
+            .iter()
+            .map(|s| SegmentLayout {
+                row_groups: s.row_groups.clone(),
+            })
+            .collect();
+        let assignments = compute_assignments(&segInfo, num_partitions);
+
+        let properties = PlanProperties::new(
+            EquivalenceProperties::new(output_schema.clone()),
+            Partitioning::UnknownPartitioning(assignments.len()),
+            datafusion::physical_plan::execution_plan::EmissionType::Incremental,
+            datafusion::physical_plan::execution_plan::Boundedness::Bounded,
+        );
+
+        Ok(Arc::new(QueryShardExec {
+            schema: output_schema,
+            full_schema: self.schema.clone(),
+            segments: self.segments.clone(),
+            assignments,
+            projection: projection.cloned(),
+            properties,
+            filters: filters.to_vec(),
+            predicate,
+            searcher: Arc::clone(&self.searcher),
+            bitset_mode: self.bitset_mode,
+            force_pushdown: self.force_pushdown,
+            force_strategy: self.force_strategy,
+            metrics: ExecutionPlanMetricsSet::new(),
+            inner_parquet_metrics: Arc::new(std::sync::Mutex::new(Vec::new())),
+        }))
+    }
+
+    fn supports_filters_pushdown(
+        &self,
+        filters: &[&Expr],
+    ) -> Result<Vec<TableProviderFilterPushDown>> {
+        Ok(filters
+            .iter()
+            .map(|f| {
+                if is_comparison_filter(f) {
+                    TableProviderFilterPushDown::Inexact
+                } else {
+                    TableProviderFilterPushDown::Unsupported
+                }
+            })
+            .collect())
+    }
+}
+
+fn is_comparison_filter(filter: &Expr) -> bool {
+    if let Expr::BinaryExpr(binary) = filter {
+        matches!(
+            binary.op,
+            Operator::Lt | Operator::LtEq | Operator::Gt | Operator::GtEq | Operator::Eq | Operator::NotEq
+        )
+    } else {
+        false
+    }
+}
+
+/// Execution plan for shard queries with partition assignments.
+///
+/// Carries a single `ShardSearcher` + `BitsetMode`. Each partition creates
+/// a cheap `SegmentCollector` from the searcher, then reads parquet.
+pub struct QueryShardExec {
+    schema: SchemaRef,
+    full_schema: SchemaRef,
+    segments: Vec<SegmentFileInfo>,
+    assignments: Vec<PartitionAssignment>,
+    projection: Option<Vec<usize>>,
+    properties: PlanProperties,
+    filters: Vec<Expr>,
+    predicate: Option<Arc<dyn datafusion::physical_expr::PhysicalExpr>>,
+    searcher: Arc<dyn ShardSearcher>,
+    bitset_mode: BitsetMode,
+    force_pushdown: Option<bool>,
+    force_strategy: Option<FilterStrategy>,
+    metrics: ExecutionPlanMetricsSet,
+    inner_parquet_metrics: Arc<std::sync::Mutex<Vec<MetricsSet>>>,
+}
+
+impl std::fmt::Debug for QueryShardExec {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("QueryShardExec")
+            .field("segments", &self.segments.len())
+            .field("partitions", &self.assignments.len())
+            .field("bitset_mode", &self.bitset_mode)
+            .finish()
+    }
+}
+
+impl DisplayAs for QueryShardExec {
+    fn fmt_as(&self, _t: DisplayFormatType, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let total_rgs: usize = self.segments.iter().map(|s| s.row_groups.len()).sum();
+        let total_rows: i64 = self.segments.iter()
+            .flat_map(|s| &s.row_groups)
+            .map(|rg| rg.num_rows)
+            .sum();
+        write!(
+            f,
+            "QueryShardExec: segments={}, partitions={}, rg={}, rows={}, mode={:?}",
+            self.segments.len(),
+            self.assignments.len(),
+            total_rgs,
+            total_rows,
+            self.bitset_mode,
+        )
+    }
+}
+
+impl ExecutionPlan for QueryShardExec {
+    fn name(&self) -> &str { "QueryShardExec" }
+    fn as_any(&self) -> &dyn Any { self }
+    fn schema(&self) -> SchemaRef { self.schema.clone() }
+    fn properties(&self) -> &PlanProperties { &self.properties }
+    fn children(&self) -> Vec<&Arc<dyn ExecutionPlan>> { vec![] }
+
+    fn with_new_children(
+        self: Arc<Self>,
+        _children: Vec<Arc<dyn ExecutionPlan>>,
+    ) -> Result<Arc<dyn ExecutionPlan>> {
+        Ok(self)
+    }
+
+    fn metrics(&self) -> Option<MetricsSet> {
+        let mut combined = self.metrics.clone_inner();
+        if let Ok(inner_sets) = self.inner_parquet_metrics.lock() {
+            for inner_set in inner_sets.iter() {
+                for metric in inner_set.iter() {
+                    combined.push(Arc::clone(metric));
+                }
+            }
+        }
+        Some(combined)
+    }
+
+    fn execute(
+        &self,
+        partition: usize,
+        context: Arc<datafusion::execution::TaskContext>,
+    ) -> Result<datafusion::execution::SendableRecordBatchStream> {
+        let pm = PartitionMetrics::new(&self.metrics, partition);
+
+        if partition >= self.assignments.len() {
+            return Ok(Box::pin(
+                datafusion::physical_plan::stream::EmptyRecordBatchStream::new(self.schema.clone()),
+            ));
+        }
+
+        let assignment = &self.assignments[partition];
+        if assignment.chunks.is_empty() {
+            return Ok(Box::pin(
+                datafusion::physical_plan::stream::EmptyRecordBatchStream::new(self.schema.clone()),
+            ));
+        }
+
+        // Defer scorer creation to poll time so RepartitionExec can create all
+        // partition streams instantly, then when it spawns tokio tasks to poll them,
+        // the JNI scorer calls run in parallel across worker threads.
+        let schema = self.schema.clone();
+        let schema_outer = schema.clone();
+        let full_schema = self.full_schema.clone();
+        let segments = self.segments.clone();
+        let chunks = assignment.chunks.clone();
+        let projection = self.projection.clone();
+        let filters = self.filters.clone();
+        let predicate = self.predicate.clone();
+        let searcher = Arc::clone(&self.searcher);
+        let bitset_mode = self.bitset_mode;
+        let force_pushdown = self.force_pushdown;
+        let force_strategy = self.force_strategy;
+
+        let stream_metrics =
+            pm.into_stream_metrics(Some(Arc::clone(&self.inner_parquet_metrics)));
+
+        let partition_id = partition;
+        let lazy_stream = futures::stream::once(async move {
+            let mut streams: Vec<datafusion::execution::SendableRecordBatchStream> = Vec::new();
+
+            for (chunk_idx, chunk) in chunks.iter().enumerate() {
+                let segment = &segments[chunk.segment_idx];
+
+                let partition_row_groups: Vec<RowGroupInfo> = chunk
+                    .row_group_indices
+                    .iter()
+                    .filter_map(|&rg_idx| segment.row_groups.get(rg_idx).cloned())
+                    .collect();
+
+                if partition_row_groups.is_empty() {
+                    continue;
+                }
+
+                eprintln!("[PARTITION-DEBUG] partition={}, chunk={}/{}, seg={}, doc_range=[{}, {}), rgs={:?}, thread={:?}",
+                    partition_id, chunk_idx, chunks.len(), chunk.segment_idx,
+                    chunk.doc_min, chunk.doc_max,
+                    chunk.row_group_indices, std::thread::current().name());
+
+                let collector = match searcher.collector(
+                    segment.segment_ord as usize,
+                    chunk.doc_min,
+                    chunk.doc_max,
+                ) {
+                    Ok(c) => c,
+                    Err(_) => continue,
+                };
+
+                let properties = PlanProperties::new(
+                    EquivalenceProperties::new(schema.clone()),
+                    Partitioning::UnknownPartitioning(1),
+                    datafusion::physical_plan::execution_plan::EmissionType::Incremental,
+                    datafusion::physical_plan::execution_plan::Boundedness::Bounded,
+                );
+
+                let indexed_exec = IndexedExec {
+                    schema: schema.clone(),
+                    full_schema: full_schema.clone(),
+                    file_path: segment.parquet_path.clone(),
+                    file_size: segment.parquet_size,
+                    row_groups: partition_row_groups,
+                    projection: projection.clone(),
+                    properties,
+                    metadata: Arc::clone(&segment.metadata),
+                    filters: filters.clone(),
+                    predicate: predicate.clone(),
+                    collector: std::sync::Mutex::new(Some(collector)),
+                    bitset_mode,
+                    doc_range: Some((chunk.doc_min, chunk.doc_max)),
+                    metrics: ExecutionPlanMetricsSet::new(),
+                    stream_metrics: stream_metrics.clone(),
+                    force_pushdown,
+                    force_strategy,
+                };
+
+                match indexed_exec.execute(0, Arc::clone(&context)) {
+                    Ok(s) => streams.push(s),
+                    Err(_) => continue,
+                }
+            }
+
+            match streams.len() {
+                0 => Box::pin(
+                    datafusion::physical_plan::stream::EmptyRecordBatchStream::new(schema.clone()),
+                ) as datafusion::execution::SendableRecordBatchStream,
+                1 => streams.into_iter().next().unwrap(),
+                _ => {
+                    let chained = futures::stream::iter(streams).flatten();
+                    Box::pin(RecordBatchStreamAdapter::new(schema.clone(), chained))
+                        as datafusion::execution::SendableRecordBatchStream
+                }
+            }
+        }).flatten();
+
+        Ok(Box::pin(RecordBatchStreamAdapter::new(schema_outer, lazy_stream)))
+    }
+}
diff --git a/plugins/engine-datafusion/jni/src/lib.rs b/plugins/engine-datafusion/jni/src/lib.rs
index 65d4d53b1ba44..29706e370ef01 100644
--- a/plugins/engine-datafusion/jni/src/lib.rs
+++ b/plugins/engine-datafusion/jni/src/lib.rs
@@ -48,6 +48,8 @@ mod runtime_manager;
 mod cache_jni;
 mod partial_agg_optimizer;
 mod query_executor;
+mod indexed_query_executor;
+mod indexed_table;
 mod project_row_id_analyzer;
 pub mod logger;
 
@@ -730,13 +732,9 @@ pub extern "system" fn Java_org_opensearch_datafusion_jni_NativeBridge_streamNex
     let stream_ptr = stream;
     let io_runtime = manager.io_runtime.clone();
 
-    // TODO : this can be 'io_runtime.block_on' if we see rust workers getting overloaded
-    // benchmarks so far are good with spawn
-    // TODO : Thread leaks in tests if its spawn
     io_runtime.block_on(async move {
 
         let stream = unsafe { &mut *(stream_ptr as *mut RecordBatchStreamAdapter<CrossRtStream>) };
-        // Poll the stream with monitoring
         let result = stream.try_next().await;
 
         // Uncomment for monitoring stream next
@@ -904,3 +902,170 @@ pub extern "system" fn Java_org_opensearch_datafusion_jni_NativeBridge_streamClo
 ) {
     let _ = unsafe { Box::from_raw(stream as *mut RecordBatchStreamAdapter<CrossRtStream>) };
 }
+
+/// Execute an indexed query asynchronously.
+///
+/// Registers an IndexedTableProvider under `tableName`, then executes the
+/// substrait plan against it — same response path as executeQueryPhaseAsync.
+#[no_mangle]
+pub extern "system" fn Java_org_opensearch_datafusion_jni_NativeBridge_executeIndexedQueryAsync(
+    mut env: JNIEnv,
+    _class: JClass,
+    weight_ptr: jlong,
+    segment_max_docs: JLongArray,
+    parquet_paths: JObjectArray,
+    table_name: JString,
+    substrait_bytes: jbyteArray,
+    num_partitions: jint,
+    bitset_mode: jint,
+    is_query_plan_explain_enabled: jboolean,
+    runtime_ptr: jlong,
+    listener: JObject,
+) {
+    use crate::indexed_table::index::BitsetMode;
+
+    let manager = match TOKIO_RUNTIME_MANAGER.get() {
+        Some(m) => m,
+        None => {
+            log_error!("Runtime manager not initialized");
+            set_action_listener_error(&mut env, listener,
+                &DataFusionError::Execution("Runtime manager not initialized".to_string()));
+            return;
+        }
+    };
+
+    // Extract all Java data before async block
+    let seg_max_docs = {
+        let len = match env.get_array_length(&segment_max_docs) {
+            Ok(l) => l as usize,
+            Err(e) => {
+                set_action_listener_error(&mut env, listener,
+                    &DataFusionError::Execution(format!("get_array_length: {}", e)));
+                return;
+            }
+        };
+        let mut buf = vec![0i64; len];
+        if let Err(e) = env.get_long_array_region(segment_max_docs, 0, &mut buf) {
+            set_action_listener_error(&mut env, listener,
+                &DataFusionError::Execution(format!("get_long_array_region: {}", e)));
+            return;
+        }
+        buf
+    };
+
+    let pq_paths = match parse_string_arr(&mut env, parquet_paths) {
+        Ok(paths) => paths,
+        Err(e) => {
+            set_action_listener_error(&mut env, listener,
+                &DataFusionError::Execution(format!("parse parquet paths: {}", e)));
+            return;
+        }
+    };
+
+    let tbl_name: String = match env.get_string(&table_name) {
+        Ok(s) => s.into(),
+        Err(e) => {
+            set_action_listener_error(&mut env, listener,
+                &DataFusionError::Execution(format!("Failed to get table name: {}", e)));
+            return;
+        }
+    };
+
+    let plan_bytes_obj = unsafe { JByteArray::from_raw(substrait_bytes) };
+    let plan_bytes_vec = match env.convert_byte_array(plan_bytes_obj) {
+        Ok(bytes) => bytes,
+        Err(e) => {
+            set_action_listener_error(&mut env, listener,
+                &DataFusionError::Execution(format!("Failed to convert plan bytes: {}", e)));
+            return;
+        }
+    };
+
+    let n = (num_partitions as usize).max(1);
+    let mode = match bitset_mode {
+        1 => BitsetMode::Or,
+        _ => BitsetMode::And,
+    };
+
+    let jvm = match JAVA_VM.get() {
+        Some(vm) => Arc::new(unsafe {
+            JavaVM::from_raw(vm.get_java_vm_pointer())
+                .expect("Failed to create JavaVM from pointer")
+        }),
+        None => {
+            set_action_listener_error(&mut env, listener,
+                &DataFusionError::Execution("JavaVM not initialized".to_string()));
+            return;
+        }
+    };
+
+    let listener_ref = match env.new_global_ref(&listener) {
+        Ok(r) => r,
+        Err(e) => {
+            log_error!("Failed to create global ref: {}", e);
+            set_action_listener_error(&mut env, listener,
+                &DataFusionError::Execution(format!("Failed to create global ref: {}", e)));
+            return;
+        }
+    };
+
+    // Pre-resolve the LuceneIndexSearcher class on the calling thread (which has the plugin classloader).
+    // Tokio worker threads use the system classloader and can't find plugin classes.
+    let searcher_class_ref = match env.find_class("org/opensearch/datafusion/search/LuceneIndexSearcher") {
+        Ok(cls) => match env.new_global_ref(cls) {
+            Ok(r) => r,
+            Err(e) => {
+                set_action_listener_error(&mut env, listener,
+                    &DataFusionError::Execution(format!("Failed to create global ref for LuceneIndexSearcher: {}", e)));
+                return;
+            }
+        },
+        Err(e) => {
+            set_action_listener_error(&mut env, listener,
+                &DataFusionError::Execution(format!("Failed to find LuceneIndexSearcher class: {}", e)));
+            return;
+        }
+    };
+
+    let io_runtime = manager.io_runtime.clone();
+    let cpu_executor = manager.cpu_executor();
+    let runtime = unsafe { &*(runtime_ptr as *const DataFusionRuntime) };
+
+    let is_explain: bool = is_query_plan_explain_enabled != 0;
+
+    // Use spawn + blocking channel instead of block_on.
+    // block_on occupies the calling thread as a worker, causing RepartitionExec's
+    // spawned tasks to serialize on that thread. spawn() lets the io_runtime's
+    // worker threads handle the tasks concurrently.
+    let (tx, rx) = std::sync::mpsc::channel();
+
+    io_runtime.spawn(async move {
+        let result = indexed_query_executor::execute_indexed_query_stream(
+            weight_ptr,
+            seg_max_docs,
+            pq_paths,
+            tbl_name,
+            plan_bytes_vec,
+            n,
+            mode,
+            is_explain,
+            jvm,
+            searcher_class_ref,
+            runtime,
+            cpu_executor,
+        ).await;
+        let _ = tx.send(result);
+    });
+
+    let result = rx.recv().unwrap_or_else(|_| Err(DataFusionError::Execution("Channel closed".to_string())));
+
+    match result {
+        Ok(stream_ptr) => {
+            set_action_listener_ok(&mut env, listener, stream_ptr);
+        }
+        Err(e) => {
+            log_error!("Indexed query execution failed: {}", e);
+            set_action_listener_error(&mut env, listener, &e);
+        }
+    }
+}
diff --git a/plugins/engine-datafusion/jni/src/listing_table.rs b/plugins/engine-datafusion/jni/src/listing_table.rs
index a06b0a2c55d87..0ca6f13dd5a74 100644
--- a/plugins/engine-datafusion/jni/src/listing_table.rs
+++ b/plugins/engine-datafusion/jni/src/listing_table.rs
@@ -1085,15 +1085,16 @@ impl ListingTable {
     }
 
     /// Creates a schema adapter for mapping between file and table schemas
+    ///
+    /// Uses the configured schema adapter factory if available, otherwise falls back
+    /// to the default implementation.
     /// Creates a file source and applies schema adapter factory if available
     fn create_file_source_with_schema_adapter(&self) -> Result<Arc<dyn FileSource>> {
         let table_schema = datafusion_datasource::table_schema::TableSchema::new(
             self.file_schema.clone(),
-            self.options
-                .table_partition_cols
-                .iter()
-                .map(|(name, dt)| Arc::new(Field::new(name, dt.clone(), false)) as _)
-                .collect(),
+            self.options.table_partition_cols.iter().map(|(name, dt)| {
+                Arc::new(Field::new(name, dt.clone(), false)) as _
+            }).collect(),
         );
         let mut source = self.options.format.file_source(table_schema);
         // Apply schema adapter to source if available
@@ -1464,22 +1465,21 @@ impl ListingTable {
             inexact_stats,
         )?;
 
-        // Only map statistics if schema_adapter_factory is explicitly set
-        // In DataFusion 52.1, SchemaAdapter has been removed and replaced with PhysicalExprAdapterFactory
-        // Statistics mapping is now optional and only done when explicitly configured
+        // In DF 52, SchemaAdapter is deprecated. Skip statistics schema mapping
+        // when no custom adapter is configured — the common case.
+        // The file source handles schema adaptation internally via PhysicalExprAdapterFactory.
         if let Some(factory) = &self.schema_adapter_factory {
             let schema_adapter = factory.create_with_projected_schema(self.schema());
             let (schema_mapper, _) = schema_adapter.map_schema(self.file_schema.as_ref())?;
-            
             stats.column_statistics = schema_mapper.map_column_statistics(&stats.column_statistics)?;
             file_groups.iter_mut().try_for_each(|file_group| {
                 if let Some(stat) = file_group.statistics_mut() {
-                    stat.column_statistics = schema_mapper.map_column_statistics(&stat.column_statistics)?;
+                    stat.column_statistics =
+                        schema_mapper.map_column_statistics(&stat.column_statistics)?;
                 }
                 Ok::<_, DataFusionError>(())
             })?;
         }
-        
         Ok((file_groups, stats))
     }
 
diff --git a/plugins/engine-datafusion/jni/src/query_executor.rs b/plugins/engine-datafusion/jni/src/query_executor.rs
index a98f306ef8a5b..d4798a0a898da 100644
--- a/plugins/engine-datafusion/jni/src/query_executor.rs
+++ b/plugins/engine-datafusion/jni/src/query_executor.rs
@@ -148,7 +148,7 @@ pub async fn execute_query_with_cross_rt_stream(
 
     let mut config = SessionConfig::new();
     config.options_mut().execution.parquet.pushdown_filters = false;
-    config.options_mut().execution.target_partitions = target_partitions;
+    config.options_mut().execution.target_partitions = 4;
     config.options_mut().execution.batch_size = 8192;
 
     let state = datafusion::execution::SessionStateBuilder::new()
@@ -423,6 +423,7 @@ pub async fn execute_fetch_phase(
 
     let file_group = FileGroup::new(partitioned_files);
 
+    // In DF 52, ParquetSource takes a TableSchema which includes partition columns
     let table_schema = datafusion_datasource::table_schema::TableSchema::new(
         parquet_schema.clone(),
         vec![Arc::new(Field::new(ROW_BASE_FIELD_NAME, DataType::Int64, false))],
diff --git a/plugins/engine-datafusion/jni/src/runtime_manager.rs b/plugins/engine-datafusion/jni/src/runtime_manager.rs
index 73addb3df1f10..52e728fee6b10 100644
--- a/plugins/engine-datafusion/jni/src/runtime_manager.rs
+++ b/plugins/engine-datafusion/jni/src/runtime_manager.rs
@@ -108,7 +108,7 @@ impl RuntimeManager {
         cpu_runtime_builder
             .worker_threads(config.effective_cpu_threads())
             .thread_name("datafusion-cpu")
-            .enable_time()
+            .enable_all()
             .on_thread_start(move || {
                 // Register IO runtime for each CPU thread
                 register_io_runtime(Some(io_handle.clone()));
diff --git a/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/DatafusionEngine.java b/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/DatafusionEngine.java
index 53a28413585de..83c6b29919b44 100644
--- a/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/DatafusionEngine.java
+++ b/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/DatafusionEngine.java
@@ -38,6 +38,7 @@
 import org.opensearch.datafusion.search.DatafusionReaderManager;
 import org.opensearch.datafusion.search.DatafusionSearcher;
 import org.opensearch.datafusion.search.DatafusionSearcherSupplier;
+import org.opensearch.datafusion.search.IndexedQueryBridge;
 import org.opensearch.datafusion.search.RecordBatchIterator;
 import org.opensearch.datafusion.search.cache.CacheManager;
 import org.opensearch.index.engine.CatalogSnapshotAwareRefreshListener;
@@ -212,16 +213,40 @@ public void close() {
         rootAllocator.close();
     }
 
+    /**
+     * Get the DataFusion runtime pointer for JNI calls.
+     * Used by IndexedQueryBridge for indexed query execution.
+     */
+    public long getRuntimePointer() {
+        return datafusionService.getRuntimePointer();
+    }
+
+    /**
+     * Get the DatafusionReaderManager for accessing file metadata.
+     */
+    public DatafusionReaderManager getDatafusionReaderManager() {
+        return datafusionReaderManager;
+    }
+
 
     @Override
     public void executeQueryPhase(DatafusionContext context) {
+        DatafusionSearcher datafusionSearcher = context.getEngineSearcher();
+        long streamPointer = datafusionSearcher.search(context.getDatafusionQuery(), datafusionService.getRuntimePointer());
+        consumeStreamAndSetResults(context, streamPointer);
+    }
+
+    /**
+     * Shared stream consumption logic used by both the normal DF query path
+     * and the indexed query path. Takes a stream pointer, consumes all batches,
+     * populates DF results and topDocs on the context.
+     */
+    private void consumeStreamAndSetResults(DatafusionContext context, long streamPointer) {
         Map<String, List<Object>> finalRes = new HashMap<>();
         List<Long> rowIdResult = new ArrayList<>();
         RecordBatchStream stream = null;
 
         try {
-            DatafusionSearcher datafusionSearcher = context.getEngineSearcher();
-            long streamPointer = datafusionSearcher.search(context.getDatafusionQuery(), datafusionService.getRuntimePointer());
             stream = new RecordBatchStream(streamPointer, datafusionService.getRuntimePointer(), rootAllocator);
 
             // We can have some collectors passed like this which can collect the results and convert to InternalAggregation
@@ -257,21 +282,6 @@ public void executeQueryPhase(DatafusionContext context) {
 
             collector.collect(new RecordBatchIterator(stream));
 
-//            logger.info("Final Results:");
-//            for (Map.Entry<String, Object[]> entry : finalRes.entrySet()) {
-//                logger.info("{}: {}", entry.getKey(), java.util.Arrays.toString(entry.getValue()));
-//            }
-
-
-//            logger.info("Memory Pool Allocation Post Query ShardID:{}", context.getQueryShardContext().getShardId());
-//            printMemoryPoolAllocation(datafusionService.getRuntimePointer());
-
-
-//            logger.info("Final Results:");
-//            for (Map.Entry<String, Object[]> entry : finalRes.entrySet()) {
-//                logger.info("{}: {}", entry.getKey(), java.util.Arrays.toString(entry.getValue()));
-//            }
-
         } catch (Exception exception) {
             logger.error("Failed to execute Substrait query plan", exception);
             throw new RuntimeException(exception);
@@ -301,36 +311,7 @@ public void executeQueryPhaseAsync(DatafusionContext context, Executor executor,
                 if(streamPointer == null) {
                     throw new RuntimeException(error);
                 }
-                RootAllocator allocator = new RootAllocator(Long.MAX_VALUE);
-                RecordBatchStream stream = new RecordBatchStream(streamPointer, datafusionService.getRuntimePointer() , allocator);
-                SearchResultsCollector<RecordBatchStream> collector = new SearchResultsCollector<RecordBatchStream>() {
-                    @Override
-                    public void collect(RecordBatchStream value) {
-                        VectorSchemaRoot root = value.getVectorSchemaRoot();
-                        for (Field field : root.getSchema().getFields()) {
-                            String fieldName = field.getName();
-                            FieldVector fieldVector = root.getVector(fieldName);
-                            List<Object> fieldValues = new ArrayList<>(fieldVector.getValueCount());
-                            if (fieldName.equals(CompositeDataFormatWriter.ROW_ID)) {
-                                FieldVector rowIdVector = root.getVector(fieldName);
-                                for(int i=0; i<fieldVector.getValueCount(); i++) {
-                                    rowIdResult.add((long) rowIdVector.getObject(i));
-                                    fieldValues.add(fieldVector.getObject(i));
-                                }
-                            } else {
-                                for (int i = 0; i < fieldVector.getValueCount(); i++) {
-                                    fieldValues.add(fieldVector.getObject(i));
-                                }
-                            }
-                            if(finalResColumns.containsKey(fieldName)) {
-                                finalResColumns.get(fieldName).addAll(fieldValues);
-                            } else {
-                                finalResColumns.put(fieldName, fieldValues);
-                            }
-                        }
-                    }
-                };
-                loadNextBatch(stream, executor, collector, finalResColumns, allocator, listener, context, rowIdResult);
+                collect(context, executor, listener, streamPointer, finalResColumns, rowIdResult);
             });
 
 //            logger.info("Memory Pool Allocation Post Query ShardID:{}", context.getQueryShardContext().getShardId());
@@ -349,6 +330,40 @@ public void collect(RecordBatchStream value) {
         //return finalRes;
     }
 
+    private void collect(DatafusionContext context, Executor executor, ActionListener<QueryResult> listener, Long streamPointer, Map<String, List<Object>> finalRes, List<Long> rowIdResult) {
+        RootAllocator allocator = new RootAllocator(Long.MAX_VALUE);
+        RecordBatchStream stream = new RecordBatchStream(streamPointer, datafusionService.getRuntimePointer() , allocator);
+        SearchResultsCollector<RecordBatchStream> collector = new SearchResultsCollector<RecordBatchStream>() {
+            @Override
+            public void collect(RecordBatchStream value) {
+                VectorSchemaRoot root = value.getVectorSchemaRoot();
+                for (Field field : root.getSchema().getFields()) {
+                    String fieldName = field.getName();
+                    FieldVector fieldVector = root.getVector(fieldName);
+                    List<Object> fieldValues = new ArrayList<>(fieldVector.getValueCount());
+                    if (fieldName.equals(CompositeDataFormatWriter.ROW_ID)) {
+                        FieldVector rowIdVector = root.getVector(fieldName);
+                        for(int i=0; i<fieldVector.getValueCount(); i++) {
+                            rowIdResult.add((long) rowIdVector.getObject(i));
+                            fieldValues.add(fieldVector.getObject(i));
+                        }
+                    }
+                    else {
+                        for (int i = 0; i < fieldVector.getValueCount(); i++) {
+                            fieldValues.add(fieldVector.getObject(i));
+                        }
+                    }
+                    if (finalRes.containsKey(fieldName)) {
+                        finalRes.get(fieldName).addAll(fieldValues);
+                    } else {
+                        finalRes.put(fieldName, fieldValues);
+                    }
+                }
+            }
+        };
+        loadNextBatch(stream, executor, collector, finalRes, allocator, listener, context, rowIdResult);
+    }
+
     private void loadNextBatch(
         RecordBatchStream stream,
         Executor executor,
@@ -528,4 +543,69 @@ public Map<String, FileStats> fetchSegmentStats() throws IOException {
             return datafusionReader.fetchSegmentStats();
         }
     }
+
+    @Override
+    public void executeIndexedQuery(
+        org.apache.lucene.index.DirectoryReader luceneReader,
+        org.apache.lucene.search.Query query,
+        int numPartitions,
+        int bitsetMode,
+        org.opensearch.core.action.ActionListener<Long> listener
+    ) {
+        listener.onFailure(new UnsupportedOperationException(
+            "Use executeIndexedQuery with tableName and substraitBytes instead"));
+    }
+
+    /**
+     * Execute an indexed query with substrait plan — passes through to IndexedQueryBridge directly.
+     * No blocking — the listener is called asynchronously when the stream is ready.
+     */
+    public void executeIndexedQuery(
+        org.apache.lucene.index.DirectoryReader luceneReader,
+        org.apache.lucene.search.Query query,
+        String tableName,
+        byte[] substraitBytes,
+        int numPartitions,
+        int bitsetMode,
+        boolean isQueryPlanExplainEnabled,
+        org.opensearch.core.action.ActionListener<Long> listener
+    ) {
+        logger.info("[INDEXED-DEBUG] DatafusionEngine.executeIndexedQuery: thread={}, tableName={}, substraitBytes={}",
+            Thread.currentThread().getName(), tableName, substraitBytes != null ? substraitBytes.length + " bytes" : "null");
+        try {
+            DatafusionReader dfReader = datafusionReaderManager.acquire();
+
+            IndexedQueryBridge.executeIndexedQuery(
+                luceneReader,
+                query,
+                dfReader.files,
+                dfReader.directoryPath,
+                tableName,
+                substraitBytes,
+                numPartitions,
+                bitsetMode,
+                isQueryPlanExplainEnabled,
+                datafusionService.getRuntimePointer(),
+                listener
+            );
+        } catch (Exception e) {
+            listener.onFailure(e);
+        }
+    }
+
+    /**
+     * Execute the query phase using a pre-obtained stream pointer (from indexed query).
+     * Uses the same async stream consumption as executeQueryPhaseAsync — identical response path.
+     */
+    public void executeQueryPhaseWithStreamPointer(DatafusionContext context, long streamPointer, Executor executor, ActionListener<Map<String, Object[]>> listener) {
+        logger.info("[INDEXED-DEBUG] executeQueryPhaseWithStreamPointer: thread={}, streamPtr={}", Thread.currentThread().getName(), streamPointer);
+        Map<String, List<Object>> finalRes = new HashMap<>();
+        List<Long> rowIdResult = new ArrayList<>();
+        collect(context, executor, ActionListener.map(listener, qr -> {
+            // Convert QueryResult columns to Object[] map for the caller
+            Map<String, Object[]> result = new HashMap<>();
+            qr.getColumns().forEach((k, v) -> result.put(k, v.toArray()));
+            return result;
+        }), streamPointer, finalRes, rowIdResult);
+    }
 }
diff --git a/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/jni/NativeBridge.java b/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/jni/NativeBridge.java
index 887be1c0a55ff..ef8eeacbb2e33 100644
--- a/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/jni/NativeBridge.java
+++ b/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/jni/NativeBridge.java
@@ -78,6 +78,35 @@ private NativeBridge() {}
     // Other methods
     public static native String getVersionInfo();
 
+
+    /**
+     * Execute an indexed query asynchronously using a pre-built Lucene Weight.
+     *
+     * Java creates the Weight (expensive, once per query), gathers segment metadata,
+     * and passes everything to Rust. Rust builds JniShardSearcher → IndexedTableProvider
+     * → DataFusion pipeline and returns a CrossRtStream pointer.
+     *
+     * @param weightPtr      Pointer to the Java-side Lucene Weight (from LuceneIndexSearcher)
+     * @param segmentMaxDocs Max doc count per segment (long[])
+     * @param parquetPaths   One parquet file path per segment (String[])
+     * @param numPartitions  Number of DataFusion partitions
+     * @param bitsetMode     0 = AND (intersect bitset with page pruner), 1 = OR (union)
+     * @param runtimePtr     Pointer to the DataFusion runtime
+     * @param listener       ActionListener to receive the stream pointer (Long)
+     */
+    public static native void executeIndexedQueryAsync(
+        long weightPtr,
+        long[] segmentMaxDocs,
+        String[] parquetPaths,
+        String tableName,
+        byte[] substraitBytes,
+        int numPartitions,
+        int bitsetMode,
+        boolean isQueryPlanExplainEnabled,
+        long runtimePtr,
+        ActionListener<Long> listener
+    );
+
     /**
      * Test method: Creates a sliced StringArray and returns FFI pointers.
      * Used to verify that sliced arrays across FFI boundary are handled correctly
diff --git a/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/search/DatafusionReaderManager.java b/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/search/DatafusionReaderManager.java
index 4fe2342915361..61e207a4e012a 100644
--- a/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/search/DatafusionReaderManager.java
+++ b/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/search/DatafusionReaderManager.java
@@ -40,7 +40,7 @@ public class DatafusionReaderManager implements EngineReaderManager<DatafusionRe
 //    private final List<ReferenceManager.RefreshListener> refreshListeners = new CopyOnWriteArrayList();
 
     public DatafusionReaderManager(String path, Collection<FileMetadata> files, String dataFormat) throws IOException {
-        WriterFileSet writerFileSet = new WriterFileSet(Path.of(URI.create("file:///" + path)), 1, 0);
+        WriterFileSet writerFileSet = new WriterFileSet(Path.of(URI.create("file:///" + path)), 1, 0, false);
         files.forEach(fileMetadata -> writerFileSet.add(fileMetadata.file()));
         this.current = new DatafusionReader(path, null, List.of(writerFileSet));
         this.path = path;
diff --git a/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/search/IndexedQueryBridge.java b/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/search/IndexedQueryBridge.java
new file mode 100644
index 0000000000000..30106603d2322
--- /dev/null
+++ b/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/search/IndexedQueryBridge.java
@@ -0,0 +1,173 @@
+/*
+ * 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.datafusion.search;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Weight;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.datafusion.jni.NativeBridge;
+import org.opensearch.index.engine.exec.WriterFileSet;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Bridge between OpenSearch's Lucene index and the indexed-table Rust crate.
+ *
+ * Orchestrates the Lucene+DataFusion indexed query flow:
+ * 1. Takes a Lucene Query and the shard's WriterFileSets (segment→parquet mapping)
+ * 2. Creates a Lucene Weight from the query
+ * 3. Registers it with LuceneIndexSearcher for JNI callbacks
+ * 4. Gathers segment metadata (maxDoc per segment, parquet paths)
+ * 5. Calls NativeBridge.executeIndexedQueryAsync() to run the indexed query
+ * 6. Returns a stream pointer consumable via streamNext/streamGetSchema
+ */
+public class IndexedQueryBridge {
+
+    private static final Logger logger = LogManager.getLogger(IndexedQueryBridge.class);
+
+    /**
+     * Execute an indexed query using Lucene indexes to accelerate parquet reads.
+     *
+     * @param luceneReader  The Lucene DirectoryReader for this shard
+     * @param query         The Lucene query to execute
+     * @param fileSets      The WriterFileSets mapping segments to parquet files
+     * @param dataDir       The base data directory path
+     * @param numPartitions Number of DataFusion partitions
+     * @param bitsetMode    0 = AND (intersect), 1 = OR (union)
+     * @param runtimePtr    Pointer to the DataFusion runtime
+     * @param listener      ActionListener to receive the stream pointer
+     */
+    public static void executeIndexedQuery(
+        DirectoryReader luceneReader,
+        Query query,
+        Collection<WriterFileSet> fileSets,
+        String dataDir,
+        String tableName,
+        byte[] substraitBytes,
+        int numPartitions,
+        int bitsetMode,
+        boolean isQueryPlanExplainEnabled,
+        long runtimePtr,
+        ActionListener<Long> listener
+    ) {
+        try {
+            // 1. Create Lucene Weight from the query
+            IndexSearcher searcher = new IndexSearcher(luceneReader);
+            searcher.setQueryCache(null); // TODO: enable caching based on settings
+            Query rewritten = searcher.rewrite(query);
+            // TODO: enable scoring
+            Weight weight = searcher.createWeight(rewritten, ScoreMode.COMPLETE_NO_SCORES, 1.0f);
+            List<LeafReaderContext> leaves = luceneReader.leaves();
+
+            // 2. Register the Weight with LuceneIndexSearcher for JNI callbacks
+            long weightPtr = LuceneIndexSearcher.registerShardWeight(searcher, weight, leaves);
+
+            // 3. Build segment metadata arrays
+            // Map Lucene segments to parquet files using writer_generation attribute.
+            // Each Lucene segment has a writer_generation stored in SegmentInfo attributes.
+            // Each WriterFileSet has a matching writerGeneration.
+            // We iterate Lucene leaves (which define segment ordinals for scoring)
+            // and find the corresponding parquet file by matching generation.
+
+            // Build a map from writerGeneration -> WriterFileSet for O(1) lookup
+            java.util.Map<Long, WriterFileSet> genToFileSet = new java.util.HashMap<>();
+            for (WriterFileSet fs : fileSets) {
+                genToFileSet.put(fs.getWriterGeneration(), fs);
+            }
+
+            long[] segmentMaxDocs = new long[leaves.size()];
+            String[] parquetPaths = new String[leaves.size()];
+
+            for (int i = 0; i < leaves.size(); i++) {
+                segmentMaxDocs[i] = leaves.get(i).reader().maxDoc();
+
+                // Get writer_generation from Lucene segment attributes
+                long writerGen = -1;
+                if (leaves.get(i).reader() instanceof org.apache.lucene.index.SegmentReader) {
+                    String genAttr = ((org.apache.lucene.index.SegmentReader) leaves.get(i).reader())
+                        .getSegmentInfo().info.getAttribute("writer_generation");
+                    if (genAttr != null) {
+                        writerGen = Long.parseLong(genAttr);
+                    }
+                }
+
+                // Find the matching WriterFileSet by generation
+                WriterFileSet fileSet = genToFileSet.get(writerGen);
+                if (fileSet != null) {
+                    String dir = fileSet.getDirectory();
+                    String parquetFile = fileSet.getFiles().stream()
+                        .filter(f -> f.endsWith(".parquet"))
+                        .findFirst()
+                        .orElse(null);
+                    parquetPaths[i] = parquetFile != null ? Path.of(dir, parquetFile).toString() : "";
+                } else {
+                    parquetPaths[i] = "";
+                }
+
+                logger.info("[INDEXED-DEBUG] leaf[{}]: maxDoc={}, writerGen={}, parquet={}",
+                    i, segmentMaxDocs[i], writerGen, parquetPaths[i]);
+            }
+
+            // 4. Call native indexed query
+            // NOTE: The weight is NOT released here. The caller must call
+            // LuceneIndexSearcher.releaseShardWeight(weightPtr) after the stream
+            // is fully consumed, because Rust calls back into Java for scoring
+            // while the stream is being read.
+            logger.info("[INDEXED-DEBUG] IndexedQueryBridge: segments={}, partitions={}, bitsetMode={}, weightPtr={}, tableName={}, substraitBytes={}",
+                leaves.size(), numPartitions, bitsetMode, weightPtr, tableName,
+                substraitBytes != null ? substraitBytes.length + " bytes" : "null");
+
+            NativeBridge.executeIndexedQueryAsync(
+                weightPtr,
+                segmentMaxDocs,
+                parquetPaths,
+                tableName,
+                substraitBytes,
+                numPartitions,
+                bitsetMode,
+                isQueryPlanExplainEnabled,
+                runtimePtr,
+                ActionListener.wrap(
+                    streamPtr -> {
+                        // Don't release weight here — Rust still needs it while streaming
+                        listener.onResponse(streamPtr);
+                    },
+                    e -> {
+                        // On failure, safe to release since no stream will be consumed
+                        LuceneIndexSearcher.releaseShardWeight(weightPtr);
+                        listener.onFailure(e);
+                    }
+                )
+            );
+
+        } catch (IOException e) {
+            logger.error("Failed to execute indexed query", e);
+            listener.onFailure(e);
+        }
+    }
+
+    /**
+     * Get the weight pointer for the most recently registered weight.
+     * Used by the caller to release the weight after stream consumption.
+     */
+    public static void releaseWeight(long weightPtr) {
+        LuceneIndexSearcher.releaseShardWeight(weightPtr);
+    }
+}
diff --git a/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/search/LuceneIndexSearcher.java b/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/search/LuceneIndexSearcher.java
new file mode 100644
index 0000000000000..5b3cf071cae7e
--- /dev/null
+++ b/plugins/engine-datafusion/src/main/java/org/opensearch/datafusion/search/LuceneIndexSearcher.java
@@ -0,0 +1,200 @@
+/*
+ * 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.datafusion.search;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.*;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Lucene index searcher with static JNI callback methods for Rust integration.
+ *
+ * Rust's JniShardSearcher calls these static methods via JNI to:
+ * 1. Create partition scorers from a shard-level Weight
+ * 2. Collect matching doc IDs as bitsets for each row group
+ * 3. Release scorer resources
+ *
+ * The Weight pointer is a key into {@link #activeShardWeights} — Java owns the
+ * Weight lifecycle, Rust borrows it for the duration of the native call.
+ */
+public class LuceneIndexSearcher {
+
+    private static final Logger logger = LogManager.getLogger(LuceneIndexSearcher.class);
+
+    // Active ShardWeight contexts (one per query)
+    private static final Map<Long, ShardWeightContext> activeShardWeights = new ConcurrentHashMap<>();
+
+    // Active PartitionScorer contexts (one per partition per segment)
+    private static final Map<Long, PartitionScorerContext> activePartitionScorers = new ConcurrentHashMap<>();
+
+    // ID generator for pointers
+    private static final AtomicLong nextId = new AtomicLong(1);
+
+    /**
+     * Context holding a shard-level Weight and its segment leaves.
+     */
+    static class ShardWeightContext {
+        final IndexSearcher searcher;
+        final Weight weight;
+        final List<LeafReaderContext> leaves;
+
+        ShardWeightContext(IndexSearcher searcher, Weight weight, List<LeafReaderContext> leaves) {
+            this.searcher = searcher;
+            this.weight = weight;
+            this.leaves = leaves;
+        }
+    }
+
+    /**
+     * Context holding a partition-scoped scorer for a single segment.
+     */
+    static class PartitionScorerContext {
+        final DocIdSetIterator iterator;
+        final int partitionMinDocId;
+        final int partitionMaxDocId;
+        int currentDoc;
+
+        PartitionScorerContext(DocIdSetIterator iterator, int minDocId, int maxDocId) {
+            this.iterator = iterator;
+            this.partitionMinDocId = minDocId;
+            this.partitionMaxDocId = maxDocId;
+            this.currentDoc = -1;
+        }
+    }
+
+    /**
+     * Register a pre-built Weight for use by Rust via JNI.
+     *
+     * Called by the OpenSearch query path after creating the Weight from the
+     * user's query. Returns a pointer (ID) that Rust uses to reference this Weight.
+     *
+     * @param searcher The IndexSearcher that created the Weight
+     * @param weight   The pre-built Weight
+     * @param leaves   Segment leaf contexts
+     * @return pointer ID for this Weight context
+     */
+    public static long registerShardWeight(IndexSearcher searcher, Weight weight, List<LeafReaderContext> leaves) {
+        long id = nextId.getAndIncrement();
+        activeShardWeights.put(id, new ShardWeightContext(searcher, weight, leaves));
+        return id;
+    }
+
+    public static int getShardWeightSegmentCount(long shardWeightPointer) {
+        ShardWeightContext context = activeShardWeights.get(shardWeightPointer);
+        return (context != null) ? context.leaves.size() : -1;
+    }
+
+    public static int getShardWeightSegmentMaxDoc(long shardWeightPointer, int segmentOrd) {
+        ShardWeightContext context = activeShardWeights.get(shardWeightPointer);
+        if (context == null || segmentOrd < 0 || segmentOrd >= context.leaves.size()) {
+            return -1;
+        }
+        return context.leaves.get(segmentOrd).reader().maxDoc();
+    }
+
+    public static void releaseShardWeight(long shardWeightPointer) {
+        activeShardWeights.remove(shardWeightPointer);
+    }
+
+    /**
+     * Create a partition scorer for a specific segment and doc ID range.
+     * Called by Rust's JniShardSearcher.collector().
+     */
+    public static long createPartitionScorerFromShard(long shardWeightPointer, int segmentOrd, int minDocId, int maxDocId) {
+        ShardWeightContext shardCtx = activeShardWeights.get(shardWeightPointer);
+        if (shardCtx == null) {
+            logger.error("Invalid ShardWeight pointer: {}", shardWeightPointer);
+            return -1;
+        }
+
+        if (segmentOrd < 0 || segmentOrd >= shardCtx.leaves.size()) {
+            logger.error("Invalid segment ordinal: {}", segmentOrd);
+            return -1;
+        }
+
+        try {
+            LeafReaderContext leafContext = shardCtx.leaves.get(segmentOrd);
+            long st = System.nanoTime();
+
+            Scorer scorer = shardCtx.weight.scorer(leafContext);
+            logger.info("scorer took : {} ms for : {}, {}, {} " , (System.nanoTime() - st) / 1_000_000, segmentOrd, minDocId,maxDocId);
+            if (scorer == null) {
+                return -1;  // No matches in this segment
+            }
+
+            DocIdSetIterator iterator = scorer.iterator();
+            long id = nextId.getAndIncrement();
+            activePartitionScorers.put(id, new PartitionScorerContext(iterator, minDocId, maxDocId));
+            return id;
+
+        } catch (Exception e) {
+            logger.error("Error creating PartitionScorer for segment {}: {}", segmentOrd, e.getMessage());
+            return -1;
+        }
+    }
+
+    /**
+     * Get matching doc IDs for a row group range as a bitset.
+     * Called by Rust's JniShardSearcher SegmentCollector.collect().
+     *
+     * Returns a long[] representing a java.util.BitSet — each bit corresponds
+     * to a doc ID relative to effectiveMin.
+     */
+    public static long[] getNextRowGroupDocs(long scorerPointer, int rowGroupMin, int rowGroupMax) {
+        PartitionScorerContext context = activePartitionScorers.get(scorerPointer);
+        if (context == null) {
+            return new long[0];
+        }
+
+        int effectiveMin = Math.max(rowGroupMin, context.partitionMinDocId);
+        int effectiveMax = Math.min(rowGroupMax, context.partitionMaxDocId);
+
+        if (effectiveMin >= effectiveMax) {
+            return new long[0];
+        }
+
+        java.util.BitSet bitSet = new java.util.BitSet(effectiveMax - effectiveMin);
+        int offset = effectiveMin;
+
+        try {
+            DocIdSetIterator iterator = context.iterator;
+            int docId = context.currentDoc;
+
+            if (docId == DocIdSetIterator.NO_MORE_DOCS || docId >= context.partitionMaxDocId) {
+                return new long[0];
+            }
+
+            if (docId < effectiveMin) {
+                docId = iterator.advance(effectiveMin);
+            }
+
+            while (docId != DocIdSetIterator.NO_MORE_DOCS && docId < effectiveMax) {
+                bitSet.set(docId - offset);
+                docId = iterator.nextDoc();
+            }
+
+            context.currentDoc = docId;
+
+        } catch (Exception e) {
+            logger.error("Error in getNextRowGroupDocs: {}", e.getMessage());
+        }
+
+        return bitSet.toLongArray();
+    }
+
+    public static void releasePartitionScorer(long scorerPointer) {
+        activePartitionScorers.remove(scorerPointer);
+    }
+}
diff --git a/sandbox/libs/analytics-framework/src/main/java/org/opensearch/analytics/backend/EngineBridge.java b/sandbox/libs/analytics-framework/src/main/java/org/opensearch/analytics/backend/EngineBridge.java
index 0a242b619650c..e320b889d06af 100644
--- a/sandbox/libs/analytics-framework/src/main/java/org/opensearch/analytics/backend/EngineBridge.java
+++ b/sandbox/libs/analytics-framework/src/main/java/org/opensearch/analytics/backend/EngineBridge.java
@@ -54,4 +54,17 @@ public interface EngineBridge<Fragment, Stream extends EngineResultStream, Logic
      * @return an opaque handle to the native result stream
      */
     Stream execute(Fragment fragment);
+
+    /**
+     * Wraps an externally-obtained native stream pointer into a consumable
+     * result stream. Used by the indexed query path where the stream is
+     * produced by the Lucene+Parquet indexed table provider rather than
+     * the normal substrait execution path.
+     *
+     * @param streamPointer native memory pointer to the result stream
+     * @return a consumable result stream
+     */
+    default Stream consumeStream(long streamPointer) {
+        throw new UnsupportedOperationException("consumeStream not supported by this bridge");
+    }
 }
diff --git a/sandbox/plugins/analytics-backend-datafusion/src/main/java/org/opensearch/be/datafusion/SandboxDataFusionBridge.java b/sandbox/plugins/analytics-backend-datafusion/src/main/java/org/opensearch/be/datafusion/SandboxDataFusionBridge.java
index cb03d14f508db..895dfc9542ba2 100644
--- a/sandbox/plugins/analytics-backend-datafusion/src/main/java/org/opensearch/be/datafusion/SandboxDataFusionBridge.java
+++ b/sandbox/plugins/analytics-backend-datafusion/src/main/java/org/opensearch/be/datafusion/SandboxDataFusionBridge.java
@@ -215,6 +215,14 @@ public void onFailure(Exception e) {
         return new ResultStream(streamPtr, runtimePtr, allocator);
     }
 
+    /**
+     * Wraps an externally-obtained stream pointer into a consumable ResultStream.
+     */
+    @Override
+    public ResultStream consumeStream(long streamPtr) {
+        return new ResultStream(streamPtr, runtimePtr, new org.apache.arrow.memory.RootAllocator(Long.MAX_VALUE));
+    }
+
     @Override
     public void close() {
         reader.close();
diff --git a/sandbox/plugins/analytics-engine/src/main/java/org/opensearch/analytics/exec/DefaultPlanExecutor.java b/sandbox/plugins/analytics-engine/src/main/java/org/opensearch/analytics/exec/DefaultPlanExecutor.java
index 67d6949facd0b..1e067a155efad 100644
--- a/sandbox/plugins/analytics-engine/src/main/java/org/opensearch/analytics/exec/DefaultPlanExecutor.java
+++ b/sandbox/plugins/analytics-engine/src/main/java/org/opensearch/analytics/exec/DefaultPlanExecutor.java
@@ -9,7 +9,13 @@
 package org.opensearch.analytics.exec;
 
 import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Filter;
 import org.apache.calcite.rel.core.TableScan;
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.rex.RexInputRef;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.sql.SqlKind;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.analytics.backend.EngineBridge;
@@ -20,13 +26,17 @@
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
+import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.IndexService;
+import org.opensearch.index.engine.SearchExecEngine;
+import org.opensearch.index.engine.exec.IndexFilterProvider;
 import org.opensearch.index.engine.exec.coord.CatalogSnapshot;
 import org.opensearch.index.engine.exec.coord.CompositeEngine;
 import org.opensearch.plugins.spi.vectorized.DataFormat;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.indices.IndicesService;
+import org.opensearch.search.SearchService;
 
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -34,6 +44,9 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * {@link QueryPlanExecutor} default implementation.
@@ -88,16 +101,6 @@ public Iterable<Object[]> execute(RelNode logicalFragment, Object context) {
 
         CompositeEngine engine = (CompositeEngine) indexShard.getIndexer();
 
-//        // Prefer SearchExecEngine path if supported
-//        if (plugin.supportsSearchExecEngine() && engine.getSearchBackendFactory() != null) {
-//            logger.info("[DefaultPlanExecutor] Using SearchExecEngine path for back-end [{}]", plugin.name());
-//            try {
-//                return executeViaSearchExecEngine(engine, logicalFragment);
-//            } catch (Exception e) {
-//                throw new RuntimeException("SearchExecEngine execution failed for [" + plugin.name() + "]", e);
-//            }
-//        }
-
         // Bridge path
         try (CompositeEngine.ReleasableRef<CatalogSnapshot> snapshot = engine.acquireSnapshot()) {
             EngineBridge<byte[], ? extends EngineResultStream, RelNode> bridge =
@@ -105,6 +108,13 @@ public Iterable<Object[]> execute(RelNode logicalFragment, Object context) {
 
             byte[] converted = bridge.convertFragment(logicalFragment);
 
+            // Check if indexed query path is enabled — route through Lucene+Parquet indexed table
+            // TODO : wire DF + Lucene - this is just to validate that once wired , query in backend will work
+            if (clusterService.getClusterSettings().get(SearchService.INDEXED_QUERY_ENABLED_SETTING)) {
+                logger.info("[DefaultPlanExecutor] Indexed query enabled, routing through Lucene+Parquet indexed table");
+                return executeViaIndexedQuery(engine, tableName, converted, logicalFragment);
+            }
+
             List<Object[]> rows = new ArrayList<>();
             try (EngineResultStream resultStream = bridge.execute(converted)) {
                 EngineResultBatchIterator batchIterator = resultStream.iterator();
@@ -204,6 +214,78 @@ IndexShard getIndexShard(ShardId shardId) {
      * @return the selected back-end plugin
      * @throws IllegalStateException if no back-end plugins are registered
      */
+    @SuppressWarnings("unchecked")
+    private List<Object[]> executeViaIndexedQuery(
+        CompositeEngine compositeEngine,
+        String tableName,
+        byte[] substraitBytes,
+        RelNode logicalFragment
+    ) {
+        try {
+            org.apache.lucene.index.IndexWriter luceneWriter = compositeEngine.getLuceneIndexWriter();
+            if (luceneWriter == null) {
+                throw new IllegalStateException("Indexed query requires a Lucene IndexWriter");
+            }
+            org.apache.lucene.index.DirectoryReader luceneReader =
+                org.apache.lucene.index.DirectoryReader.open(luceneWriter);
+
+            int partitions = clusterService.getClusterSettings().get(SearchService.INDEXED_QUERY_PARTITIONS_SETTING);
+            int bitsetMode = clusterService.getClusterSettings().get(SearchService.INDEXED_QUERY_BITSET_MODE_SETTING);
+
+            // Extract Lucene query from the logical plan's filter predicates.
+            // e.g. `where URL = 'google'` -> TermQuery(URL, google)
+            //       `where URL like '%google%'` -> WildcardQuery(URL, *google*)
+            // Falls back to MatchAllDocsQuery if no filter is present.
+            org.apache.lucene.search.Query luceneQuery = buildLuceneQueryFromPlan(logicalFragment);
+
+            logger.info("[DefaultPlanExecutor] Indexed query: luceneQuery={}, segments={}",
+                luceneQuery, luceneReader.leaves().size());
+
+            @SuppressWarnings("rawtypes")
+            SearchExecEngine searchExecEngine = compositeEngine.getPrimaryReadEngine();
+
+            CompletableFuture<Long> streamFuture = new CompletableFuture<>();
+            searchExecEngine.executeIndexedQuery(
+                luceneReader, luceneQuery, tableName, substraitBytes,
+                partitions, bitsetMode, true,
+                new ActionListener<Long>() {
+                    @Override
+                    public void onResponse(Long streamPtr) { streamFuture.complete(streamPtr); }
+                    @Override
+                    public void onFailure(Exception e) { streamFuture.completeExceptionally(e); }
+                }
+            );
+            long streamPtr = streamFuture.join();
+
+            // Consume the stream using the bridge's consumeStream (wraps the native pointer)
+            AnalyticsBackEndPlugin bePlugin = selectBackEnd();
+            try (CompositeEngine.ReleasableRef<CatalogSnapshot> snapshot = compositeEngine.acquireSnapshot()) {
+                EngineBridge<byte[], ? extends EngineResultStream, RelNode> bridge =
+                    (EngineBridge<byte[], ? extends EngineResultStream, RelNode>) bePlugin.bridge(compositeEngine, snapshot.getRef());
+                List<Object[]> rows = new ArrayList<>();
+                try (EngineResultStream resultStream = bridge.consumeStream(streamPtr)) {
+                    EngineResultBatchIterator batchIterator = resultStream.iterator();
+                    while (batchIterator.hasNext()) {
+                        EngineResultBatch batch = batchIterator.next();
+                        List<String> fieldNames = batch.getFieldNames();
+                        for (int row = 0; row < batch.getRowCount(); row++) {
+                            Object[] rowValues = new Object[fieldNames.size()];
+                            for (int col = 0; col < fieldNames.size(); col++) {
+                                rowValues[col] = batch.getFieldValue(fieldNames.get(col), row);
+                            }
+                            rows.add(rowValues);
+                        }
+                    }
+                }
+                luceneReader.close();
+                logger.info("[DefaultPlanExecutor] Indexed query completed, {} rows", rows.size());
+                return rows;
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("Indexed query execution failed: " + e.getMessage(), e);
+        }
+    }
+
     @SuppressWarnings("unchecked")
     private List<Object[]> executeViaSearchExecEngine(
         CompositeEngine compositeEngine,
@@ -244,6 +326,141 @@ private List<Object[]> executeViaSearchExecEngine(
         return rows;
     }
 
+    /**
+     * Extracts a Lucene query from the RelNode plan tree by finding Filter nodes
+     * and converting simple equality/like predicates to TermQuery/WildcardQuery.
+     * Falls back to MatchAllDocsQuery when no extractable filter is found.
+     */
+    private org.apache.lucene.search.Query buildLuceneQueryFromPlan(RelNode node) {
+        // Walk the tree to find a Filter
+        Filter filter = findFilter(node);
+        if (filter != null) {
+            RexNode condition = filter.getCondition();
+            if (condition instanceof RexCall) {
+                RexCall call = (RexCall) condition;
+                org.apache.lucene.search.Query q = rexCallToLuceneQuery(call, filter.getInput().getRowType());
+                if (q != null) {
+                    logger.info("[DefaultPlanExecutor] Extracted Lucene query from plan filter: {}", q);
+                    return q;
+                }
+            }
+        }
+        logger.info("[DefaultPlanExecutor] No filter in plan, using MatchAllDocsQuery");
+        return new org.apache.lucene.search.MatchAllDocsQuery();
+    }
+
+    private Filter findFilter(RelNode node) {
+        if (node instanceof Filter) {
+            return (Filter) node;
+        }
+        for (RelNode input : node.getInputs()) {
+            Filter f = findFilter(input);
+            if (f != null) return f;
+        }
+        return null;
+    }
+
+    /**
+     * Converts a RexCall to a Lucene query.
+     * Supports: field = 'value' -> TermQuery
+     *           field != 'value' -> BooleanQuery(MatchAll, NOT TermQuery)
+     *           field like '%value%' -> WildcardQuery
+     */
+    private org.apache.lucene.search.Query rexCallToLuceneQuery(
+        RexCall call,
+        org.apache.calcite.rel.type.RelDataType rowType
+    ) {
+        SqlKind kind = call.getKind();
+        List<RexNode> operands = call.getOperands();
+
+        if ((kind == SqlKind.EQUALS || kind == SqlKind.NOT_EQUALS) && operands.size() == 2) {
+            String fieldName = extractFieldName(operands.get(0), rowType);
+            String value = extractLiteral(operands.get(1));
+            if (fieldName == null) {
+                fieldName = extractFieldName(operands.get(1), rowType);
+                value = extractLiteral(operands.get(0));
+            }
+            // Only build Lucene term queries for string-typed fields (keyword/text).
+            // Numeric fields aren't indexed as keyword terms in Lucene.
+            if (fieldName != null && value != null && isStringField(operands, rowType)) {
+                var termQuery = new org.apache.lucene.search.TermQuery(
+                    new org.apache.lucene.index.Term(fieldName, value));
+                if (kind == SqlKind.EQUALS) {
+                    return termQuery;
+                }
+                var bq = new org.apache.lucene.search.BooleanQuery.Builder();
+                bq.add(new org.apache.lucene.search.MatchAllDocsQuery(), org.apache.lucene.search.BooleanClause.Occur.MUST);
+                bq.add(termQuery, org.apache.lucene.search.BooleanClause.Occur.MUST_NOT);
+                return bq.build();
+            }
+        }
+
+        if (kind == SqlKind.LIKE && operands.size() == 2) {
+            String fieldName = extractFieldName(operands.get(0), rowType);
+            String pattern = extractLiteral(operands.get(1));
+            if (fieldName != null && pattern != null) {
+                String lucenePattern = pattern.replace('%', '*').replace('_', '?');
+                return new org.apache.lucene.search.WildcardQuery(
+                    new org.apache.lucene.index.Term(fieldName, lucenePattern));
+            }
+        }
+
+        if (kind == SqlKind.AND) {
+            var bq = new org.apache.lucene.search.BooleanQuery.Builder();
+            boolean hasClause = false;
+            for (RexNode operand : operands) {
+                if (operand instanceof RexCall) {
+                    var sub = rexCallToLuceneQuery((RexCall) operand, rowType);
+                    if (sub != null) {
+                        bq.add(sub, org.apache.lucene.search.BooleanClause.Occur.MUST);
+                        hasClause = true;
+                    }
+                }
+            }
+            return hasClause ? bq.build() : null;
+        }
+
+        return null;
+    }
+
+    private boolean isStringField(List<RexNode> operands, org.apache.calcite.rel.type.RelDataType rowType) {
+        for (RexNode op : operands) {
+            if (op instanceof RexInputRef) {
+                var sqlType = rowType.getFieldList().get(((RexInputRef) op).getIndex()).getType().getSqlTypeName();
+                return sqlType == org.apache.calcite.sql.type.SqlTypeName.VARCHAR
+                    || sqlType == org.apache.calcite.sql.type.SqlTypeName.CHAR;
+            }
+        }
+        return false;
+    }
+
+    private String extractFieldName(RexNode node, org.apache.calcite.rel.type.RelDataType rowType) {
+        if (node instanceof RexInputRef) {
+            int idx = ((RexInputRef) node).getIndex();
+            return rowType.getFieldList().get(idx).getName();
+        }
+        return null;
+    }
+
+    private String extractLiteral(RexNode node) {
+        if (node instanceof RexLiteral) {
+            RexLiteral lit = (RexLiteral) node;
+            Comparable<?> val = lit.getValue();
+            if (val == null) return null;
+            // NlsString (charset-prefixed string) — extract the raw value
+            String className = val.getClass().getSimpleName();
+            if ("NlsString".equals(className)) {
+                try {
+                    return (String) val.getClass().getMethod("getValue").invoke(val);
+                } catch (Exception e) {
+                    return val.toString();
+                }
+            }
+            return val.toString();
+        }
+        return null;
+    }
+
     private AnalyticsBackEndPlugin selectBackEnd() {
         if (backEnds.isEmpty()) {
             throw new IllegalStateException("No analytics back-end plugins registered");
diff --git a/sandbox/qa/analytics-engine-rest/build.gradle b/sandbox/qa/analytics-engine-rest/build.gradle
index 6ee2842f96baf..75eb8b5c7234a 100644
--- a/sandbox/qa/analytics-engine-rest/build.gradle
+++ b/sandbox/qa/analytics-engine-rest/build.gradle
@@ -29,6 +29,7 @@ testClusters.integTest {
     plugin ':sandbox:plugins:test-ppl-frontend'
     plugin ':plugins:engine-datafusion'
     plugin ':sandbox:plugins:analytics-backend-datafusion'
+    plugin ':modules:parquet-data-format'
 
     // Arrow/Flight JVM flags for DataFusion native library
     jvmArgs '--add-opens=java.base/java.nio=ALL-UNNAMED'
diff --git a/sandbox/qa/analytics-engine-rest/src/test/java/org/opensearch/analytics/qa/IndexedLuceneRestIT.java b/sandbox/qa/analytics-engine-rest/src/test/java/org/opensearch/analytics/qa/IndexedLuceneRestIT.java
new file mode 100644
index 0000000000000..9e706a2949028
--- /dev/null
+++ b/sandbox/qa/analytics-engine-rest/src/test/java/org/opensearch/analytics/qa/IndexedLuceneRestIT.java
@@ -0,0 +1,210 @@
+/*
+ * 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.analytics.qa;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.client.Request;
+import org.opensearch.client.Response;
+import org.opensearch.test.rest.OpenSearchRestTestCase;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Integration test verifying the Lucene indexed table + Parquet DataFusion
+ * query path produces correct results.
+ *
+ * Flow: PPL query via /_analytics/ppl
+ *   -> DefaultPlanExecutor detects search.indexed_query.enabled=true
+ *   -> converts RelNode to substrait bytes
+ *   -> opens Lucene NRT reader, builds Lucene query from cluster settings
+ *   -> calls SearchExecEngine.executeIndexedQuery (IndexedTableProvider in Rust)
+ *   -> consumes stream via bridge.consumeStream
+ *   -> returns results
+ */
+public class IndexedLuceneRestIT extends OpenSearchRestTestCase {
+
+    private static final Logger logger = LogManager.getLogger(IndexedLuceneRestIT.class);
+    private static final String INDEX = "hits_indexed";
+
+    @Override
+    protected boolean preserveClusterUponCompletion() {
+        return true;
+    }
+
+    @Override
+    protected boolean preserveIndicesUponCompletion() {
+        return true;
+    }
+
+    private void createIndex() throws IOException {
+        try {
+            client().performRequest(new Request("DELETE", "/" + INDEX));
+        } catch (Exception e) {
+            // ignore
+        }
+        Request req = new Request("PUT", "/" + INDEX);
+        req.setJsonEntity("{\n"
+            + "  \"settings\": {\n"
+            + "    \"index.number_of_shards\": 1,\n"
+            + "    \"index.number_of_replicas\": 0,\n"
+            + "    \"optimized.enabled\": true,\n"
+            + "    \"index.composite.secondary_data_formats\": [\"Lucene\"]\n"
+            + "  },\n"
+            + "  \"mappings\": {\n"
+            + "    \"properties\": {\n"
+            + "      \"AdvEngineID\": {\"type\": \"short\"},\n"
+            + "      \"Age\": {\"type\": \"short\"},\n"
+            + "      \"CounterID\": {\"type\": \"integer\"},\n"
+            + "      \"RegionID\": {\"type\": \"integer\"},\n"
+            + "      \"SearchPhrase\": {\"type\": \"keyword\"},\n"
+            + "      \"URL\": {\"type\": \"keyword\"},\n"
+            + "      \"UserID\": {\"type\": \"long\"},\n"
+            + "      \"Title\": {\"type\": \"keyword\"}\n"
+            + "    }\n"
+            + "  }\n"
+            + "}");
+        client().performRequest(req);
+    }
+
+    private void bulkInsert() throws IOException {
+        StringBuilder bulk = new StringBuilder();
+        String action = "{\"index\":{\"_index\":\"" + INDEX + "\"}}\n";
+
+        // Doc 1: URL contains "google" (via google.com)
+        bulk.append(action);
+        bulk.append("{\"AdvEngineID\":2,\"Age\":25,\"CounterID\":62,\"RegionID\":229,"
+            + "\"SearchPhrase\":\"clickbench test\","
+            + "\"URL\":\"http://www.google.com/search?q=test\","
+            + "\"UserID\":100000001,\"Title\":\"Test Page\"}\n");
+
+        // Doc 2: URL does NOT contain "google"
+        bulk.append(action);
+        bulk.append("{\"AdvEngineID\":0,\"Age\":30,\"CounterID\":62,\"RegionID\":1,"
+            + "\"SearchPhrase\":\"\","
+            + "\"URL\":\"http://example.com/mobile\","
+            + "\"UserID\":100000002,\"Title\":\"Mobile Page\"}\n");
+
+        // Doc 3: URL contains "google" (via google.com)
+        bulk.append(action);
+        bulk.append("{\"AdvEngineID\":0,\"Age\":35,\"CounterID\":62,\"RegionID\":229,"
+            + "\"SearchPhrase\":\"opensearch analytics\","
+            + "\"URL\":\"http://mail.google.com/inbox\","
+            + "\"UserID\":435090932899640449,\"Title\":\"Google Mail\"}\n");
+
+        // Doc 4: URL does NOT contain "google"
+        bulk.append(action);
+        bulk.append("{\"AdvEngineID\":0,\"Age\":28,\"CounterID\":62,\"RegionID\":50,"
+            + "\"SearchPhrase\":\"\","
+            + "\"URL\":\"http://example.com/analytics\","
+            + "\"UserID\":100000004,\"Title\":\"Analytics\"}\n");
+
+        // Doc 5: URL does NOT contain "google"
+        bulk.append(action);
+        bulk.append("{\"AdvEngineID\":3,\"Age\":45,\"CounterID\":62,\"RegionID\":229,"
+            + "\"SearchPhrase\":\"best search engine\","
+            + "\"URL\":\"http://example.jp/search\","
+            + "\"UserID\":100000007,\"Title\":\"Search Results\"}\n");
+
+        Request bulkReq = new Request("POST", "/" + INDEX + "/_bulk");
+        bulkReq.setJsonEntity(bulk.toString());
+        bulkReq.addParameter("refresh", "true");
+        bulkReq.setOptions(bulkReq.getOptions().toBuilder()
+            .addHeader("Content-Type", "application/x-ndjson")
+            .build());
+        Response resp = client().performRequest(bulkReq);
+        assertEquals(200, resp.getStatusLine().getStatusCode());
+    }
+
+    private void setIndexedQuery(boolean enabled) throws IOException {
+        Request req = new Request("PUT", "/_cluster/settings");
+        req.setJsonEntity("{\"transient\": {\"search.indexed_query.enabled\": " + enabled + "}}");
+        client().performRequest(req);
+    }
+
+    @SuppressWarnings("unchecked")
+    private List<List<Object>> runPPL(String ppl) throws IOException {
+        Request req = new Request("POST", "/_analytics/ppl");
+        req.setJsonEntity("{\"query\": \"" + ppl.replace("\\", "\\\\").replace("\"", "\\\"") + "\"}");
+        Response resp = client().performRequest(req);
+        assertEquals(200, resp.getStatusLine().getStatusCode());
+        Map<String, Object> map = entityAsMap(resp);
+        return (List<List<Object>>) map.get("rows");
+    }
+
+    /**
+     * Verifies the indexed Lucene+Parquet path produces correct results.
+     *
+     * The Lucene query is auto-derived from the PPL filter predicates:
+     *   where URL = 'x'   -> TermQuery(URL, x)
+     *   where AdvEngineID != 0 -> BooleanQuery(MatchAll, NOT TermQuery)
+     *   no filter          -> MatchAllDocsQuery
+     * The substrait plan handles the full aggregation/projection.
+     */
+    public void testIndexedLuceneQueryPath() throws Exception {
+        createIndex();
+        bulkInsert();
+
+        client().performRequest(new Request("POST", "/" + INDEX + "/_refresh"));
+        Request health = new Request("GET", "/_cluster/health/" + INDEX);
+        health.addParameter("wait_for_status", "green");
+        health.addParameter("timeout", "60s");
+        client().performRequest(health);
+
+        // 1. Baseline via vanilla path
+        List<List<Object>> baselineCount = runPPL("source=" + INDEX + " | stats count()");
+        assertEquals(1, baselineCount.size());
+        assertEquals("Baseline COUNT(*)", 5L, ((Number) baselineCount.get(0).get(0)).longValue());
+
+        setIndexedQuery(true);
+        try {
+            // 2. No filter -> MatchAllDocsQuery -> all 5 docs
+            List<List<Object>> allCount = runPPL("source=" + INDEX + " | stats count()");
+            assertEquals(1, allCount.size());
+            assertEquals("COUNT(*) no filter", 5L, ((Number) allCount.get(0).get(0)).longValue());
+            logger.info("PASS: no-filter COUNT(*) = 5");
+
+            // 3. Term query: where Title = 'Analytics' -> doc 4 only
+            List<List<Object>> termCount = runPPL("source=" + INDEX + " | where Title = 'Analytics' | stats count()");
+            assertEquals(1, termCount.size());
+            assertEquals("COUNT where Title='Analytics'", 1L, ((Number) termCount.get(0).get(0)).longValue());
+            logger.info("PASS: term query Title='Analytics' COUNT = 1");
+
+            // 4. Term query with aggregation: where Title = 'Analytics' -> doc 4 (Age=28)
+            List<List<Object>> termSum = runPPL("source=" + INDEX + " | where Title = 'Analytics' | stats sum(Age)");
+            assertEquals(1, termSum.size());
+            assertEquals("SUM(Age) where Title='Analytics'", 28L, ((Number) termSum.get(0).get(0)).longValue());
+            logger.info("PASS: term query SUM(Age) = 28");
+
+            // 5. != filter: where AdvEngineID != 0 -> docs 1 (AdvEngineID=2) and 5 (AdvEngineID=3)
+            List<List<Object>> neqCount = runPPL("source=" + INDEX + " | where AdvEngineID!=0 | stats count()");
+            assertEquals(1, neqCount.size());
+            assertEquals("COUNT where AdvEngineID!=0", 2L, ((Number) neqCount.get(0).get(0)).longValue());
+            logger.info("PASS: != filter COUNT = 2");
+
+            // 6. MAX through indexed path on all docs
+            List<List<Object>> maxResult = runPPL("source=" + INDEX + " | stats max(UserID)");
+            assertEquals(1, maxResult.size());
+            assertEquals("MAX(UserID)", 435090932899640449L, ((Number) maxResult.get(0).get(0)).longValue());
+            logger.info("PASS: MAX(UserID) = 435090932899640449");
+
+            // 7. DISTINCT_COUNT
+            List<List<Object>> dcResult = runPPL("source=" + INDEX + " | stats distinct_count(RegionID)");
+            assertEquals(1, dcResult.size());
+            assertEquals("DISTINCT_COUNT(RegionID)", 3L, ((Number) dcResult.get(0).get(0)).longValue());
+            logger.info("PASS: DISTINCT_COUNT(RegionID) = 3");
+
+            logger.info("All indexed Lucene+Parquet query assertions PASSED");
+        } finally {
+            setIndexedQuery(false);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
index 3091c80e63133..11d355e41d177 100644
--- a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
@@ -872,7 +872,15 @@ public void apply(Settings value, Settings current, Settings previous) {
 
                 SearchService.CLUSTER_SEARCH_QUERY_PLAN_EXPLAIN_SETTING,
                 SearchService.NATIVE_CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE,
-                SearchService.NATIVE_CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING
+                SearchService.NATIVE_CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING,
+
+                // Indexed query settings (Lucene+DataFusion)
+                SearchService.INDEXED_QUERY_ENABLED_SETTING,
+                SearchService.INDEXED_QUERY_FIELD_SETTING,
+                SearchService.INDEXED_QUERY_TERM_SETTING,
+                SearchService.INDEXED_QUERY_TYPE_SETTING,
+                SearchService.INDEXED_QUERY_PARTITIONS_SETTING,
+                SearchService.INDEXED_QUERY_BITSET_MODE_SETTING
             )
         )
     );
diff --git a/server/src/main/java/org/opensearch/index/IndexSettings.java b/server/src/main/java/org/opensearch/index/IndexSettings.java
index f3b1eef34c079..d3fc75bf98855 100644
--- a/server/src/main/java/org/opensearch/index/IndexSettings.java
+++ b/server/src/main/java/org/opensearch/index/IndexSettings.java
@@ -859,7 +859,7 @@ private void setSearchQueryPlanExplainEnabled(Boolean searchQueryPlaneExplainEna
 
     public static final Setting<Boolean> OPTIMIZED_INDEX_ENABLED_SETTING = Setting.boolSetting(
         "index.optimized.enabled",
-        false,
+        true,
         Property.IndexScope,
         Property.Final
     );
diff --git a/server/src/main/java/org/opensearch/index/engine/InternalEngine.java b/server/src/main/java/org/opensearch/index/engine/InternalEngine.java
index 814b5848c5be3..aef23e8e73952 100644
--- a/server/src/main/java/org/opensearch/index/engine/InternalEngine.java
+++ b/server/src/main/java/org/opensearch/index/engine/InternalEngine.java
@@ -130,6 +130,7 @@
 import java.io.Closeable;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -186,8 +187,8 @@ public class InternalEngine extends Engine {
     protected String historyUUID;
 
     private final OpenSearchConcurrentMergeScheduler mergeScheduler;
-    private final ExternalReaderManager externalReaderManager;
-    private final OpenSearchReaderManager internalReaderManager;
+    private volatile ExternalReaderManager externalReaderManager;
+    private volatile OpenSearchReaderManager internalReaderManager;
 
     private final Lock flushLock = new ReentrantLock();
     private final ReentrantLock optimizeLock = new ReentrantLock();
@@ -643,8 +644,11 @@ private ExternalReaderManager createReaderManager(RefreshWarmerListener external
         OpenSearchReaderManager internalReaderManager = null;
         try {
             try {
+                final DirectoryReader rawReader = engineConfig.getIndexSettings().isOptimizedIndex()
+                    ? DirectoryReader.open(store.directory())
+                    : DirectoryReader.open(indexWriter);
                 final OpenSearchDirectoryReader directoryReader = OpenSearchDirectoryReader.wrap(
-                    DirectoryReader.open(indexWriter),
+                    rawReader,
                     shardId
                 );
                 internalReaderManager = new OpenSearchReaderManager(directoryReader);
@@ -668,6 +672,32 @@ private ExternalReaderManager createReaderManager(RefreshWarmerListener external
         }
     }
 
+    /**
+     * Reinitialize the reader manager to use an external IndexWriter (e.g. from LuceneCommitEngine)
+     * for NRT reads. This allows the InternalEngine's searcher infrastructure to see data written
+     * by the CompositeEngine.
+     */
+    public void reinitReaderManager(IndexWriter externalWriter) throws IOException {
+        final OpenSearchDirectoryReader directoryReader = OpenSearchDirectoryReader.wrap(
+            DirectoryReader.open(externalWriter),
+            shardId
+        );
+        OpenSearchReaderManager newInternalRM = new OpenSearchReaderManager(directoryReader);
+        ExternalReaderManager newExternalRM = new ExternalReaderManager(
+            newInternalRM, new RefreshWarmerListener(logger, isClosed, engineConfig)
+        );
+        newInternalRM.addListener(versionMap);
+        for (ReferenceManager.RefreshListener listener : engineConfig.getExternalRefreshListener()) {
+            newExternalRM.addListener(listener);
+        }
+        for (ReferenceManager.RefreshListener listener : engineConfig.getInternalRefreshListener()) {
+            newInternalRM.addListener(listener);
+        }
+        this.internalReaderManager = newInternalRM;
+        this.externalReaderManager = newExternalRM;
+        logger.info("reinitReaderManager: numDocs={}, segments={}", directoryReader.numDocs(), directoryReader.leaves().size());
+    }
+
     @Override
     public GetResult get(Get get, BiFunction<String, SearcherScope, Engine.Searcher> searcherFactory) throws EngineException {
         assert Objects.equals(get.uid().field(), IdFieldMapper.NAME) : get.uid().field();
diff --git a/server/src/main/java/org/opensearch/index/engine/SearchExecEngine.java b/server/src/main/java/org/opensearch/index/engine/SearchExecEngine.java
index a920d0999c6ac..82352f90c0e21 100644
--- a/server/src/main/java/org/opensearch/index/engine/SearchExecEngine.java
+++ b/server/src/main/java/org/opensearch/index/engine/SearchExecEngine.java
@@ -56,4 +56,51 @@ public abstract class SearchExecEngine<C extends SearchContext, S extends Engine
      * Fetch Segment Stats
      */
     public abstract Map<String, FileStats> fetchSegmentStats() throws IOException;
+
+    /**
+     * Execute an indexed query using Lucene indexes to accelerate reads.
+     * Default implementation throws UnsupportedOperationException.
+     *
+     * @param luceneReader  The Lucene DirectoryReader for this shard
+     * @param query         The Lucene query to execute
+     * @param numPartitions Number of execution partitions
+     * @param bitsetMode    0 = AND (intersect), 1 = OR (union)
+     * @param listener      ActionListener to receive the stream pointer
+     */
+    public void executeIndexedQuery(
+        org.apache.lucene.index.DirectoryReader luceneReader,
+        org.apache.lucene.search.Query query,
+        int numPartitions,
+        int bitsetMode,
+        ActionListener<Long> listener
+    ) {
+        listener.onFailure(new UnsupportedOperationException("Indexed queries not supported by this engine"));
+    }
+
+    /**
+     * Execute an indexed query with substrait plan using Lucene indexes to accelerate reads.
+     * Default implementation delegates to the basic executeIndexedQuery (ignoring substrait).
+     */
+    public void executeIndexedQuery(
+        org.apache.lucene.index.DirectoryReader luceneReader,
+        org.apache.lucene.search.Query query,
+        String tableName,
+        byte[] substraitBytes,
+        int numPartitions,
+        int bitsetMode,
+        boolean isQueryPlanExplainEnabled,
+        ActionListener<Long> listener
+    ) {
+        // Default: fall back to basic version (no substrait)
+        executeIndexedQuery(luceneReader, query, numPartitions, bitsetMode, listener);
+    }
+
+    /**
+     * Execute the query phase using a pre-obtained stream pointer (e.g. from an indexed query).
+     * Consumes the stream and populates results on the context using the same async path as executeQueryPhaseAsync.
+     * Default implementation throws UnsupportedOperationException.
+     */
+    public void executeQueryPhaseWithStreamPointer(C context, long streamPointer, Executor executor, ActionListener<Map<String, Object[]>> listener) {
+        listener.onFailure(new UnsupportedOperationException("executeQueryPhaseWithStreamPointer not supported by this engine"));
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/engine/exec/commit/LuceneCommitEngine.java b/server/src/main/java/org/opensearch/index/engine/exec/commit/LuceneCommitEngine.java
index cb4ed5c4f6057..f89711bf81b86 100644
--- a/server/src/main/java/org/opensearch/index/engine/exec/commit/LuceneCommitEngine.java
+++ b/server/src/main/java/org/opensearch/index/engine/exec/commit/LuceneCommitEngine.java
@@ -62,6 +62,7 @@ public LuceneCommitEngine(Store store, TranslogDeletionPolicy translogDeletionPo
         IndexWriterConfig indexWriterConfig = new IndexWriterConfig();
         indexWriterConfig.setIndexDeletionPolicy(combinedDeletionPolicy);
         indexWriterConfig.setMergePolicy(NoMergePolicy.INSTANCE);
+        indexWriterConfig.setParentField(null); // Don't require parent field — existing indexes may not have one
         this.store = store;
         this.lastCommittedSegmentInfos = store.readLastCommittedSegmentsInfo();
         if (primaryMode) {
@@ -69,6 +70,10 @@ public LuceneCommitEngine(Store store, TranslogDeletionPolicy translogDeletionPo
         }
     }
 
+    public IndexWriter getIndexWriter() {
+        return indexWriter;
+    }
+
     @Override
     public synchronized void addLuceneIndexes(List<Segment> segments) throws IOException {
 
diff --git a/server/src/main/java/org/opensearch/index/engine/exec/coord/CompositeEngine.java b/server/src/main/java/org/opensearch/index/engine/exec/coord/CompositeEngine.java
index bfa6b1824a437..4240ec9c28586 100644
--- a/server/src/main/java/org/opensearch/index/engine/exec/coord/CompositeEngine.java
+++ b/server/src/main/java/org/opensearch/index/engine/exec/coord/CompositeEngine.java
@@ -10,8 +10,9 @@
 
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.apache.lucene.index.SegmentInfos;
 import org.apache.lucene.index.IndexCommit;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.SegmentInfos;
 import org.apache.lucene.search.ReferenceManager;
 import org.apache.lucene.store.AlreadyClosedException;
 import org.opensearch.common.Nullable;
@@ -1556,4 +1557,11 @@ public GatedCloseable<IndexCommit> acquireSafeIndexCommit() throws EngineExcepti
             throw new EngineException(shardId, "CompositeEngine committer is not a LuceneCommitEngine");
         }
     }
+
+    public IndexWriter getLuceneIndexWriter() {
+        if (compositeEngineCommitter instanceof LuceneCommitEngine) {
+            return ((LuceneCommitEngine) compositeEngineCommitter).getIndexWriter();
+        }
+        return null;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/shard/IndexShard.java b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
index f91e8b8109535..77cbfbe9ef69c 100644
--- a/server/src/main/java/org/opensearch/index/shard/IndexShard.java
+++ b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
@@ -39,6 +39,7 @@
 import org.apache.lucene.index.DirectoryReader;
 import org.apache.lucene.index.FilterDirectoryReader;
 import org.apache.lucene.index.IndexCommit;
+import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexFileNames;
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.SegmentCommitInfo;
@@ -125,6 +126,7 @@
 import org.opensearch.index.codec.CodecService;
 import org.opensearch.index.engine.CommitStats;
 import org.opensearch.index.engine.Engine;
+import org.opensearch.index.engine.InternalEngine;
 import org.opensearch.index.engine.Engine.GetResult;
 import org.opensearch.index.engine.EngineConfig;
 import org.opensearch.index.engine.EngineConfigFactory;
@@ -235,6 +237,7 @@
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.PrintStream;
+import java.io.UncheckedIOException;
 import java.nio.channels.ClosedByInterruptException;
 import java.nio.channels.FileChannel;
 import java.nio.charset.StandardCharsets;
@@ -2477,13 +2480,21 @@ public EngineSearcherSupplier<?> acquireSearcherSupplier() {
      * Acquires a point-in-time reader that can be used to create {@link Engine.Searcher}s on demand.
      */
     public EngineSearcherSupplier<?> acquireSearcherSupplier(Engine.SearcherScope scope) {
+        return acquireSearcherSupplier(scope, false);
+    }
+
+    public EngineSearcherSupplier<?> acquireSearcherSupplier(Engine.SearcherScope scope, boolean forceLucene) {
         readAllowed();
         markSearcherAccessed();
         final Engine engine = getEngine();
-        if(currentCompositeEngineReference.get() != null ) {
+        if(!forceLucene && currentCompositeEngineReference.get() != null ) {
             return currentCompositeEngineReference.get().getPrimaryReadEngine().acquireSearcherSupplier(null, scope);
         }
         return engine.acquireSearcherSupplier(this::wrapSearcher, scope);
+
+//        // For forceLucene, skip reader wrappers (DerivedSource etc.) to avoid per-term overhead
+//        return forceLucene ? engine.acquireSearcherSupplier(Function.identity(), scope)
+//            : engine.acquireSearcherSupplier(this::wrapSearcher, scope);
     }
 
     public Engine.Searcher acquireSearcher(String source) {
@@ -3215,6 +3226,11 @@ private void innerOpenEngineAndTranslog(LongSupplier globalCheckpointSupplier, b
                     TranslogEventListener.NOOP_TRANSLOG_EVENT_LISTENER
                 );
                 currentCompositeEngineReference.set(compositeEngine);
+                // Reinitialize InternalEngine's reader manager with LuceneCommitEngine's IndexWriter
+                IndexWriter luceneWriter = compositeEngine.getLuceneIndexWriter();
+                if (luceneWriter != null && newEngine instanceof InternalEngine) {
+                    ((InternalEngine) newEngine).reinitReaderManager(luceneWriter);
+                }
             }
             onNewEngine(newEngine);
             currentEngineReference.set(newEngine);
diff --git a/server/src/main/java/org/opensearch/search/DefaultSearchContext.java b/server/src/main/java/org/opensearch/search/DefaultSearchContext.java
index 8d46022d00424..768d48052f68b 100644
--- a/server/src/main/java/org/opensearch/search/DefaultSearchContext.java
+++ b/server/src/main/java/org/opensearch/search/DefaultSearchContext.java
@@ -62,6 +62,7 @@
 import org.opensearch.index.compositeindex.CompositeIndexSettings;
 import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
 import org.opensearch.index.engine.Engine;
+import org.opensearch.index.engine.EngineSearcher;
 import org.opensearch.index.mapper.MappedFieldType;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.mapper.ObjectMapper;
@@ -257,7 +258,10 @@ final class DefaultSearchContext extends SearchContext {
         this.indexService = readerContext.indexService();
         this.indexShard = readerContext.indexShard();
         this.clusterService = clusterService;
-        this.engineSearcher = (Engine.Searcher) indexShard.getEngine().acquireSearcher("search");
+        EngineSearcher<?,?> rawSearcher = readerContext.acquireSearcher("search");
+        this.engineSearcher = rawSearcher instanceof Engine.Searcher
+            ? (Engine.Searcher) rawSearcher
+            : (Engine.Searcher) indexShard.getEngine().acquireSearcher("search");
         this.concurrentSearchMode = evaluateConcurrentSearchMode(executor);
         this.searcher = new ContextIndexSearcher(
             engineSearcher.getIndexReader(),
diff --git a/server/src/main/java/org/opensearch/search/SearchService.java b/server/src/main/java/org/opensearch/search/SearchService.java
index 6a03ab4e53a3d..d7eaba3cb5c02 100644
--- a/server/src/main/java/org/opensearch/search/SearchService.java
+++ b/server/src/main/java/org/opensearch/search/SearchService.java
@@ -166,6 +166,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -465,6 +466,56 @@ public class SearchService extends AbstractLifecycleComponent implements IndexEv
     public static final int DEFAULT_SIZE = 10;
     public static final int DEFAULT_FROM = 0;
 
+    // These are dynamic cluster settings that control the Lucene query used
+    // for index-accelerated parquet reads when engine="indexed".
+    // Update at runtime: PUT _cluster/settings { "transient": { "search.indexed_query.enabled": true } }
+
+    public static final Setting<Boolean> INDEXED_QUERY_ENABLED_SETTING = Setting.boolSetting(
+        "search.indexed_query.enabled",
+        false,
+        Property.NodeScope,
+        Property.Dynamic
+    );
+
+    public static final Setting<String> INDEXED_QUERY_FIELD_SETTING = Setting.simpleString(
+        "search.indexed_query.field",
+        "url",
+        Property.NodeScope,
+        Property.Dynamic
+    );
+
+    public static final Setting<String> INDEXED_QUERY_TERM_SETTING = Setting.simpleString(
+        "search.indexed_query.term",
+        "google",
+        Property.NodeScope,
+        Property.Dynamic
+    );
+
+    public static final Setting<String> INDEXED_QUERY_TYPE_SETTING = Setting.simpleString(
+        "search.indexed_query.type",
+        "term",
+        Property.NodeScope,
+        Property.Dynamic
+    );
+
+    public static final Setting<Integer> INDEXED_QUERY_PARTITIONS_SETTING = Setting.intSetting(
+        "search.indexed_query.partitions",
+        1,
+        1,
+        64,
+        Property.NodeScope,
+        Property.Dynamic
+    );
+
+    public static final Setting<Integer> INDEXED_QUERY_BITSET_MODE_SETTING = Setting.intSetting(
+        "search.indexed_query.bitset_mode",
+        0,
+        0,
+        1,
+        Property.NodeScope,
+        Property.Dynamic
+    );
+
     private final ThreadPool threadPool;
 
     private final ClusterService clusterService;
@@ -503,6 +554,14 @@ public class SearchService extends AbstractLifecycleComponent implements IndexEv
 
     private volatile boolean allowDerivedField;
 
+    // Indexed query dynamic settings (Lucene+DataFusion)
+    private volatile boolean indexedQueryEnabled;
+    private volatile String indexedQueryField;
+    private volatile String indexedQueryTerm;
+    private volatile String indexedQueryType;
+    private volatile int indexedQueryPartitions;
+    private volatile int indexedQueryBitsetMode;
+
     private final Cancellable keepAliveReaper;
 
     private final AtomicLong idGenerator = new AtomicLong();
@@ -593,6 +652,20 @@ public SearchService(
         allowDerivedField = CLUSTER_ALLOW_DERIVED_FIELD_SETTING.get(settings);
         clusterService.getClusterSettings().addSettingsUpdateConsumer(CLUSTER_ALLOW_DERIVED_FIELD_SETTING, this::setAllowDerivedField);
 
+        // Indexed query dynamic settings
+        indexedQueryEnabled = INDEXED_QUERY_ENABLED_SETTING.get(settings);
+        clusterService.getClusterSettings().addSettingsUpdateConsumer(INDEXED_QUERY_ENABLED_SETTING, this::setIndexedQueryEnabled);
+        indexedQueryField = INDEXED_QUERY_FIELD_SETTING.get(settings);
+        clusterService.getClusterSettings().addSettingsUpdateConsumer(INDEXED_QUERY_FIELD_SETTING, this::setIndexedQueryField);
+        indexedQueryTerm = INDEXED_QUERY_TERM_SETTING.get(settings);
+        clusterService.getClusterSettings().addSettingsUpdateConsumer(INDEXED_QUERY_TERM_SETTING, this::setIndexedQueryTerm);
+        indexedQueryType = INDEXED_QUERY_TYPE_SETTING.get(settings);
+        clusterService.getClusterSettings().addSettingsUpdateConsumer(INDEXED_QUERY_TYPE_SETTING, this::setIndexedQueryType);
+        indexedQueryPartitions = INDEXED_QUERY_PARTITIONS_SETTING.get(settings);
+        clusterService.getClusterSettings().addSettingsUpdateConsumer(INDEXED_QUERY_PARTITIONS_SETTING, this::setIndexedQueryPartitions);
+        indexedQueryBitsetMode = INDEXED_QUERY_BITSET_MODE_SETTING.get(settings);
+        clusterService.getClusterSettings().addSettingsUpdateConsumer(INDEXED_QUERY_BITSET_MODE_SETTING, this::setIndexedQueryBitsetMode);
+
         this.concurrentSearchDeciderFactories = concurrentSearchDeciderFactories;
 
         this.pluginProfilers = pluginProfilers;
@@ -672,6 +745,30 @@ private void setAllowDerivedField(boolean allowDerivedField) {
         this.allowDerivedField = allowDerivedField;
     }
 
+    private void setIndexedQueryEnabled(boolean enabled) {
+        this.indexedQueryEnabled = enabled;
+    }
+
+    private void setIndexedQueryField(String field) {
+        this.indexedQueryField = field;
+    }
+
+    private void setIndexedQueryTerm(String term) {
+        this.indexedQueryTerm = term;
+    }
+
+    private void setIndexedQueryType(String type) {
+        this.indexedQueryType = type;
+    }
+
+    private void setIndexedQueryPartitions(int partitions) {
+        this.indexedQueryPartitions = partitions;
+    }
+
+    private void setIndexedQueryBitsetMode(int mode) {
+        this.indexedQueryBitsetMode = mode;
+    }
+
     private void setMaxOpenPitContext(int maxOpenPitContext) {
         this.maxOpenPitContext = maxOpenPitContext;
     }
@@ -835,10 +932,22 @@ public void onResponse(ShardSearchRequest orig) {
                         return;
                     }
                 }
-                boolean isNativeQuery = orig.source() != null && orig.source().queryPlanIR() != null;
+                boolean isNativeQuery = orig.source() != null
+                    && (orig.source().queryPlanIR() != null || "datafusion".equalsIgnoreCase(orig.source().engine()));
+                // When indexed_query.enabled is true, all native queries go through the indexed path
+                // (Lucene index + DataFusion parquet). No need for engine="indexed" in the request.
+                boolean isIndexedQuery = indexedQueryEnabled && isNativeQuery;
 
                 // Execute
-                if (isNativeQuery) {
+                if (isIndexedQuery) {
+                    // Lucene+DataFusion indexed query path — mirrors executeNativeQueryPhaseAsync
+                    getExecutor(executorName, shard).execute(new ActionRunnable<SearchPhaseResult>(listener) {
+                        @Override
+                        protected void doRun() throws Exception {
+                            executeIndexedQueryPhase(orig, task, getExecutor(Names.STREAM_SEARCH, shard), keepStatesInContext, isStreamSearch, listener);
+                        }
+                    });
+                } else if (isNativeQuery && !"lucene".equalsIgnoreCase(orig.source() != null ? orig.source().engine() : null)) {
                     getExecutor(executorName, shard).execute(new ActionRunnable<SearchPhaseResult>(listener) {
                         @Override
                         protected void doRun() throws Exception {
@@ -899,7 +1008,8 @@ private SearchPhaseResult executeQueryPhase(
             context.queryResult().from(context.from());
             context.queryResult().size(context.size());
             byte[] substraitQuery = request.source().queryPlanIR();
-            if (substraitQuery != null) {
+            boolean useNativeEngine = substraitQuery != null || "datafusion".equalsIgnoreCase(request.source().engine());
+            if (useNativeEngine && !"lucene".equalsIgnoreCase(request.source().engine()) && !"indexed".equalsIgnoreCase(request.source().engine())) {
                 // setDFResults in context
                 // TODO : remove instanceof checks
                 SearchExecEngine searchExecEngine = indexer instanceof CompositeEngine ? ((CompositeEngine) indexer).getPrimaryReadEngine() : null;
@@ -961,6 +1071,166 @@ private SearchPhaseResult executeQueryPhase(
         return result;
     }
 
+    /**
+     * Execute an indexed query that uses Lucene indexes to accelerate DataFusion parquet reads.
+     * Mirrors executeNativeQueryPhaseAsync — same async pattern, same response path.
+     * Only the request side differs: stream comes from Lucene index + parquet instead of substrait.
+     */
+    private void executeIndexedQueryPhase(
+        ShardSearchRequest request,
+        SearchShardTask task,
+        Executor executor,
+        boolean keepStatesInContext,
+        boolean isStreamSearch,
+        ActionListener<SearchPhaseResult> listener
+    ) {
+        logger.info("[INDEXED-DEBUG] executeIndexedQueryPhase START: thread={}", Thread.currentThread().getName());
+        final ReaderContext readerContext;
+        try {
+            readerContext = createOrGetReaderContext(request, keepStatesInContext);
+        } catch (Exception e) {
+            listener.onFailure(e);
+            return;
+        }
+
+        @SuppressWarnings("unchecked")
+        Indexer indexer = readerContext.indexShard().getIndexer();
+
+        Releasable readerContextRelease = null;
+        SearchContext context = null;
+
+        try {
+            readerContextRelease = readerContext.markAsUsed(getKeepAlive(request));
+            context = createContext(readerContext, request, task, true, isStreamSearch, indexer);
+
+            final Releasable finalRelease = readerContextRelease;
+            context.queryResult().from(context.from());
+            context.queryResult().size(context.size());
+            final SearchContext finalContext = context;
+
+            // Prevent cleanup in this try-catch, will be handled in callback
+            context = null;
+
+            if (!(indexer instanceof CompositeEngine)) {
+                throw new IllegalStateException("Indexed query requires a CompositeEngine indexer");
+            }
+            CompositeEngine compositeEngine = (CompositeEngine) indexer;
+            SearchExecEngine searchExecEngine = compositeEngine.getPrimaryReadEngine();
+
+            // Get the Lucene DirectoryReader via NRT from the IndexWriter.
+            // NRT reader sees the latest committed + uncommitted segments with writer_generation attributes
+            // needed for parquet file mapping.
+            org.apache.lucene.index.IndexWriter luceneWriter = compositeEngine.getLuceneIndexWriter();
+            if (luceneWriter == null) {
+                throw new IllegalStateException("Indexed query requires a Lucene IndexWriter");
+            }
+            org.apache.lucene.index.DirectoryReader luceneReader =
+                org.apache.lucene.index.DirectoryReader.open(luceneWriter);
+
+            // Build the Lucene query from dynamic cluster settings
+            // TODO : should come from search request via planner
+            String field = indexedQueryField;
+            String term = indexedQueryTerm;
+            String qType = indexedQueryType;
+
+            org.apache.lucene.search.Query luceneQuery;
+            if ("wildcard".equalsIgnoreCase(qType)) {
+                luceneQuery = new org.apache.lucene.search.WildcardQuery(
+                    new org.apache.lucene.index.Term(field, "*" + term.toLowerCase() + "*")
+                );
+            } else {
+                luceneQuery = new org.apache.lucene.search.TermQuery(
+                    new org.apache.lucene.index.Term(field, term)
+                );
+            }
+
+            logger.info("Executing indexed query: field={}, term={}, type={}, segments={}",
+                field, term, qType, luceneReader.leaves().size());
+
+            // Step 1: Get stream pointer from indexed query with substrait plan
+            String indexName = request.shardId().getIndexName();
+            byte[] substraitBytes = request.source() != null ? request.source().queryPlanIR() : null;
+
+            searchExecEngine.executeIndexedQuery(
+                luceneReader,
+                luceneQuery,
+                indexName,
+                substraitBytes,
+                indexedQueryPartitions,
+                indexedQueryBitsetMode,
+                false, // TODO: use dynamic setting for explain
+                new ActionListener<Long>() {
+                    @Override
+                    public void onResponse(Long streamPtr) {
+                        logger.info("[INDEXED-DEBUG] executeIndexedQuery.onResponse: thread={}, streamPtr={}", Thread.currentThread().getName(), streamPtr);
+                        // Step 2: Consume stream through same path as executeNativeQueryPhaseAsync
+                        searchExecEngine.executeQueryPhaseWithStreamPointer(
+                            finalContext, streamPtr, executor,
+                            new ActionListener<Map<String, Object[]>>() {
+                                @Override
+                                public void onResponse(Map<String, Object[]> result) {
+                                    logger.info("[INDEXED-DEBUG] executeQueryPhaseWithStreamPointer.onResponse: thread={}", Thread.currentThread().getName());
+                                    try {
+                                        // Convert Map<String, Object[]> to QueryResult
+                                        Map<String, List<Object>> columns = new HashMap<>();
+                                        result.forEach((k, v) -> columns.put(k, Arrays.asList(v)));
+                                        finalContext.setDFResults((QueryResult) () -> columns);
+                                        listener.onResponse(executeQueryPhase(
+                                            finalContext, readerContext, request, isStreamSearch, listener));
+                                    } catch (Exception e) {
+                                        handleFailure(e);
+                                    } finally {
+                                        try { luceneReader.close(); } catch (Exception ex) { logger.error("Error closing lucene reader", ex); }
+                                        finalContext.close();
+                                        finalRelease.close();
+                                        taskResourceTrackingService.writeTaskResourceUsage(task, clusterService.localNode().getId());
+                                    }
+                                }
+
+                                @Override
+                                public void onFailure(Exception e) {
+                                    handleFailure(e);
+                                }
+
+                                private void handleFailure(Exception e) {
+                                    logger.error("Indexed query phase failed", e);
+                                    try { luceneReader.close(); } catch (Exception ex) { logger.error("Error closing lucene searcher", ex); }
+                                    try { finalContext.close(); } catch (Exception ex) { logger.error("Error closing context", ex); }
+                                    try { finalRelease.close(); } catch (Exception ex) { logger.error("Error closing release", ex); }
+                                    processFailure(readerContext, e);
+                                    listener.onFailure(e);
+                                    try { taskResourceTrackingService.writeTaskResourceUsage(task, clusterService.localNode().getId()); } catch (Exception ex) { logger.error("Error writing task resource usage", ex); }
+                                }
+                            }
+                        );
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        logger.error("Indexed query execution failed", e);
+                        try { luceneReader.close(); } catch (Exception ex) { logger.error("Error closing lucene searcher", ex); }
+                        try { finalContext.close(); } catch (Exception ex) { logger.error("Error closing context", ex); }
+                        try { finalRelease.close(); } catch (Exception ex) { logger.error("Error closing release", ex); }
+                        processFailure(readerContext, e);
+                        listener.onFailure(e);
+                    }
+                }
+            );
+
+        } catch (Exception e) {
+            if (context != null) { try { context.close(); } catch (Exception ex) { logger.error("Error closing context", ex); } }
+            if (readerContextRelease != null) { try { readerContextRelease.close(); } catch (Exception ex) { logger.error("Error closing release", ex); } }
+            Exception exception = e;
+            if (exception instanceof ExecutionException) {
+                exception = (exception.getCause() == null || exception.getCause() instanceof Exception)
+                    ? (Exception) exception.getCause()
+                    : new OpenSearchException(exception.getCause());
+            }
+            processFailure(readerContext, exception);
+            listener.onFailure(exception);
+        }
+    }
+
     private void executeNativeQueryPhaseAsync(
         ShardSearchRequest request,
         SearchShardTask task,
@@ -1306,7 +1576,9 @@ final ReaderContext createOrGetReaderContext(ShardSearchRequest request, boolean
         IndexService indexService = indicesService.indexServiceSafe(request.shardId().getIndex());
         IndexShard shard = indexService.getShard(request.shardId().id());
         // TODO acquire search supplier
-        EngineSearcherSupplier<?> reader = shard.acquireSearcherSupplier();
+        boolean forceLucene = request.source() != null
+            && "lucene".equalsIgnoreCase(request.source().engine());
+        EngineSearcherSupplier<?> reader = shard.acquireSearcherSupplier(Engine.SearcherScope.EXTERNAL, forceLucene);
         return createAndPutReaderContext(request, indexService, shard, reader, keepStatesInContext);
     }
 
@@ -1495,7 +1767,9 @@ private SearchContext createContext(
             OriginalIndices.NONE
         );
         @SuppressWarnings("unchecked")
-        SearchExecEngine searchExecEngine = indexer instanceof CompositeEngine ? ((CompositeEngine) indexer).getPrimaryReadEngine() : null;
+        String engineParam = request.source() != null ? request.source().engine() : null;
+        SearchExecEngine searchExecEngine = "lucene".equalsIgnoreCase(engineParam) ? null
+            : (indexer instanceof CompositeEngine ? ((CompositeEngine) indexer).getPrimaryReadEngine() : null);
         SearchContext context = searchExecEngine == null ? originalContext : searchExecEngine.createContext(readerContext, request, shardTarget, task, bigArrays, originalContext, clusterService);
         try {
             if (request.scroll() != null) {
diff --git a/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java b/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java
index 442d81f585015..54473f7c5bccc 100644
--- a/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java
+++ b/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java
@@ -141,6 +141,7 @@ public final class SearchSourceBuilder implements Writeable, ToXContentObject, R
     public static final ParseField SEARCH_PIPELINE = new ParseField("search_pipeline");
     public static final ParseField VERBOSE_SEARCH_PIPELINE = new ParseField("verbose_pipeline");
     public static final ParseField QUERY_PLAN_IR = new ParseField("query_plan_ir");
+    public static final ParseField ENGINE_FIELD = new ParseField("engine");
 
     public static SearchSourceBuilder fromXContent(XContentParser parser) throws IOException {
         return fromXContent(parser, true);
@@ -235,6 +236,8 @@ public static HighlightBuilder highlight() {
 
     private byte[] queryPlanIR;
 
+    private String engine;
+
     /**
      * Constructs a new search source builder.
      */
@@ -317,6 +320,7 @@ public SearchSourceBuilder(StreamInput in) throws IOException {
         if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
             BytesReference bytesRef = in.readOptionalBytesReference();
             queryPlanIR = bytesRef != null ? BytesReference.toBytes(bytesRef) : null;
+            engine = in.readOptionalString();
         }
     }
 
@@ -406,6 +410,7 @@ public void writeTo(StreamOutput out) throws IOException {
         }
         if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
             out.writeOptionalBytesReference(queryPlanIR != null ? new BytesArray(queryPlanIR) : null);
+            out.writeOptionalString(engine);
         }
     }
 
@@ -1199,6 +1204,15 @@ public byte[] queryPlanIR() {
         return queryPlanIR;
     }
 
+    public SearchSourceBuilder engine(String engine) {
+        this.engine = engine;
+        return this;
+    }
+
+    public String engine() {
+        return engine;
+    }
+
     /**
      * Rewrites this search source builder into its primitive form. e.g. by
      * rewriting the QueryBuilder. If the builder did not change the identity
@@ -1299,6 +1313,7 @@ private SearchSourceBuilder shallowCopy(
         rewrittenBuilder.searchPipeline = searchPipeline;
         rewrittenBuilder.verbosePipeline = verbosePipeline;
         rewrittenBuilder.queryPlanIR = queryPlanIR;
+        rewrittenBuilder.engine = engine;
         return rewrittenBuilder;
     }
 
@@ -1372,6 +1387,8 @@ public void parseXContent(XContentParser parser, boolean checkTrailingTokens) th
                     verbosePipeline = parser.booleanValue();
                 } else if (QUERY_PLAN_IR.match(currentFieldName, parser.getDeprecationHandler())) {
                     queryPlanIR = parser.binaryValue();
+                } else if (ENGINE_FIELD.match(currentFieldName, parser.getDeprecationHandler())) {
+                    engine = parser.text();
                 } else {
                     throw new ParsingException(
                         parser.getTokenLocation(),
@@ -1713,6 +1730,10 @@ public XContentBuilder innerToXContent(XContentBuilder builder, Params params) t
             builder.field(QUERY_PLAN_IR.getPreferredName(), queryPlanIR);
         }
 
+        if (engine != null) {
+            builder.field(ENGINE_FIELD.getPreferredName(), engine);
+        }
+
         return builder;
     }
 
@@ -1993,7 +2014,8 @@ public int hashCode() {
             derivedFields,
             searchPipeline,
             verbosePipeline,
-            Arrays.hashCode(queryPlanIR)
+            Arrays.hashCode(queryPlanIR),
+            engine
         );
     }
 
@@ -2041,7 +2063,8 @@ public boolean equals(Object obj) {
             && Objects.equals(derivedFields, other.derivedFields)
             && Objects.equals(searchPipeline, other.searchPipeline)
             && Objects.equals(verbosePipeline, other.verbosePipeline)
-            && Arrays.equals(queryPlanIR, other.queryPlanIR);
+            && Arrays.equals(queryPlanIR, other.queryPlanIR)
+            && Objects.equals(engine, other.engine);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/search/fetch/FetchPhase.java b/server/src/main/java/org/opensearch/search/fetch/FetchPhase.java
index 3a2042bc63d02..187afb67255a1 100644
--- a/server/src/main/java/org/opensearch/search/fetch/FetchPhase.java
+++ b/server/src/main/java/org/opensearch/search/fetch/FetchPhase.java
@@ -149,7 +149,7 @@ public void execute(SearchContext context, String profileDescription) {
             throw new TaskCancelledException("cancelled task with reason: " + context.getTask().getReasonCancelled());
         }
 
-        if (context.request().source().queryPlanIR() != null) {
+        if (context.request().source().queryPlanIR() != null || "datafusion".equalsIgnoreCase(context.request().source().engine())) {
             executeNativeFetchPhase(context);
             return;
         }
diff --git a/server/src/main/java/org/opensearch/search/query/QueryPhase.java b/server/src/main/java/org/opensearch/search/query/QueryPhase.java
index 9049388ed2dd5..bfe19c5c27c03 100644
--- a/server/src/main/java/org/opensearch/search/query/QueryPhase.java
+++ b/server/src/main/java/org/opensearch/search/query/QueryPhase.java
@@ -165,14 +165,15 @@ public void execute(SearchContext searchContext) throws QueryPhaseExecutionExcep
                 );
         }
 
-        if (searchContext.getDFResults() != null) {
-            SearchEngineResultConversionUtils.convertDFResultGeneric(searchContext);
-        } else if(searchContext.request().source().queryPlanIR() == null) {
+        if(searchContext.request().source().queryPlanIR() == null && !"datafusion".equalsIgnoreCase(searchContext.request().source().engine())) {
+            LOGGER.info("QueryPhase: taking LUCENE path, searcher={}", searchContext.searcher());
             boolean rescore = executeInternal(searchContext, queryPhaseSearcher);
-             if (rescore) { // only if we do a regular search
-             rescoreProcessor.process(searchContext);
-             }
-             suggestProcessor.process(searchContext);
+            if (rescore) { // only if we do a regular search
+                rescoreProcessor.process(searchContext);
+            }
+            suggestProcessor.process(searchContext);
+        } else {
+            SearchEngineResultConversionUtils.convertDFResultGeneric(searchContext);
         }
 
         aggregationProcessor.postProcess(searchContext);
@@ -208,6 +209,7 @@ static boolean executeInternal(SearchContext searchContext) throws QueryPhaseExe
     static boolean executeInternal(SearchContext searchContext, QueryPhaseSearcher queryPhaseSearcher) throws QueryPhaseExecutionException {
         final ContextIndexSearcher searcher = searchContext.searcher();
         final IndexReader reader = searcher.getIndexReader();
+        LOGGER.info("executeInternal: reader={}, numDocs={}, maxDoc={}", reader.getClass().getName(), reader.numDocs(), reader.maxDoc());
         QuerySearchResult queryResult = searchContext.queryResult();
         queryResult.searchTimedOut(false);
         try {