address comments

Author: kyli87

kernel/src/engine/plans/parquet.rs

@@ -49,12 +49,10 @@ impl ParquetHandler for PlanBasedParquetHandler {
     }
 
     fn read_parquet_footer(&self, file: &FileMeta) -> DeltaResult<ParquetFooter> {
-        let op = IoOperation::parquet_schema(file.clone());
-        let schema = self
-            .executor
+        let op = IoOperation::parquet_footer(file.clone());
+        self.executor
             .execute_op(Operation::IoOperation(op))?
-            .into_schema()?;
-        Ok(ParquetFooter { schema })
+            .into_parquet_footer()
     }
 }
 

kernel/src/engine/sync/plan.rs

@@ -93,9 +93,9 @@ impl SyncPlanExecutor {
                 self.storage.copy_atomic(&source, &destination)?;
                 Ok(PlanResult::Unit)
             }
-            IoOperation::ParquetSchema { file } => {
+            IoOperation::ParquetFooter { file } => {
                 let footer = self.parquet.read_parquet_footer(&file)?;
-                Ok(PlanResult::Schema(footer.schema))
+                Ok(PlanResult::ParquetFooter(footer))
             }
         }
     }

kernel/src/plans/ir.rs

@@ -62,14 +62,14 @@ pub enum IoOperation {
     /// [`Error::FileAlreadyExists`](crate::Error::FileAlreadyExists) without modifying it.
     /// Returns [`PlanResult::Unit`](super::PlanResult::Unit) on success.
     AtomicCopy { source: Url, destination: Url },
-    /// Read the schema from the footer of a Parquet file.
+    /// Read the footer of a Parquet file.
     ///
-    /// Returns [`PlanResult::Schema`](super::PlanResult::Schema) containing the file's schema
-    /// converted to Delta Kernel's format. See [`ParquetHandler::read_parquet_footer`] for the
-    /// full contract.
+    /// Returns [`PlanResult::ParquetFooter`](super::PlanResult::ParquetFooter) containing the
+    /// file's footer metadata (schema and any future extensions). See
+    /// [`ParquetHandler::read_parquet_footer`] for the full contract.
     ///
     /// [`ParquetHandler::read_parquet_footer`]: crate::ParquetHandler::read_parquet_footer
-    ParquetSchema { file: FileMeta },
+    ParquetFooter { file: FileMeta },
 }
 
 impl IoOperation {
@@ -100,8 +100,8 @@ impl IoOperation {
         }
     }
 
-    pub fn parquet_schema(file: FileMeta) -> Self {
-        Self::ParquetSchema { file }
+    pub fn parquet_footer(file: FileMeta) -> Self {
+        Self::ParquetFooter { file }
     }
 }
 

kernel/src/plans/mod.rs

@@ -8,8 +8,9 @@ use bytes::Bytes;
 pub use ir::{IoOperation, Operation, QueryPlan, QueryPlanNode};
 pub use query_builder::QueryPlanBuilder;
 
-use crate::schema::SchemaRef;
-use crate::{AsAny, DeltaResult, DeltaResultIteratorStatic, EngineData, Error, FileMeta};
+use crate::{
+    AsAny, DeltaResult, DeltaResultIteratorStatic, EngineData, Error, FileMeta, ParquetFooter,
+};
 
 /// Provides the ability to execute declarative plans to the Delta Kernel.
 ///
@@ -30,41 +31,54 @@ pub enum PlanResult {
     FileMeta(DeltaResultIteratorStatic<FileMeta>),
     /// A stream of raw byte buffers.
     Bytes(DeltaResultIteratorStatic<Bytes>),
-    /// The schema of a file (e.g. a Parquet footer schema).
-    Schema(SchemaRef),
+    /// Metadata extracted from a Parquet file footer.
+    ParquetFooter(ParquetFooter),
     /// Represents the successful completion of a plan, but with no return value.
     Unit,
 }
 
 impl PlanResult {
+    /// Consumes the PlanResult and extracts the inner iterator of EngineData (assuming that it is a
+    /// PlanResult::Data variant). Returns an error if the PlanResult is not the expected variant.
     pub fn into_data(self) -> DeltaResult<DeltaResultIteratorStatic<Box<dyn EngineData>>> {
         match self {
             Self::Data(iter) => Ok(iter),
             other => Err(other.type_mismatch("Data")),
         }
     }
 
+    /// Consumes the PlanResult and extracts the inner iterator of FileMeta (assuming that it is a
+    /// PlanResult::FileMeta variant). Returns an error if the PlanResult is not the expected
+    /// variant.
     pub fn into_file_meta(self) -> DeltaResult<DeltaResultIteratorStatic<FileMeta>> {
         match self {
             Self::FileMeta(iter) => Ok(iter),
             other => Err(other.type_mismatch("FileMeta")),
         }
     }
 
+    /// Consumes the PlanResult and extracts the inner iterator of Bytes (assuming that it is a
+    /// PlanResult::Bytes variant). Returns an error if the PlanResult is not a PlanResult::Bytes
+    /// variant.
     pub fn into_bytes(self) -> DeltaResult<DeltaResultIteratorStatic<Bytes>> {
         match self {
             Self::Bytes(iter) => Ok(iter),
             other => Err(other.type_mismatch("Bytes")),
         }
     }
 
-    pub fn into_schema(self) -> DeltaResult<SchemaRef> {
+    /// Consumes the PlanResult and extracts the inner [`ParquetFooter`] (assuming that it is a
+    /// PlanResult::ParquetFooter variant). Returns an error if the PlanResult is not the expected
+    /// variant.
+    pub fn into_parquet_footer(self) -> DeltaResult<ParquetFooter> {
         match self {
-            Self::Schema(schema) => Ok(schema),
-            other => Err(other.type_mismatch("Schema")),
+            Self::ParquetFooter(footer) => Ok(footer),
+            other => Err(other.type_mismatch("ParquetFooter")),
         }
     }
 
+    /// Consumes the PlanResult, verifying that it is a PlanResult::Unit variant. Returns an error
+    /// if the PlanResult is not the expected variant.
     pub fn into_unit(self) -> DeltaResult<()> {
         match self {
             Self::Unit => Ok(()),
@@ -77,7 +91,7 @@ impl PlanResult {
             Self::Data(_) => "Data",
             Self::FileMeta(_) => "FileMeta",
             Self::Bytes(_) => "Bytes",
-            Self::Schema(_) => "Schema",
+            Self::ParquetFooter(_) => "ParquetFooter",
             Self::Unit => "Unit",
         }
     }