rename PathStrategy -> TableStrategy

Signed-off-by: Andrew Duffy <[email protected]>

Author: a10y

vortex-file/src/strategy.rs

@@ -14,9 +14,9 @@ use vortex_layout::layouts::compressed::CompressingStrategy;
 use vortex_layout::layouts::compressed::CompressorPlugin;
 use vortex_layout::layouts::dict::writer::DictStrategy;
 use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
-use vortex_layout::layouts::path::PathStrategy;
 use vortex_layout::layouts::repartition::RepartitionStrategy;
 use vortex_layout::layouts::repartition::RepartitionWriterOptions;
+use vortex_layout::layouts::table::TableStrategy;
 use vortex_layout::layouts::zoned::writer::ZonedLayoutOptions;
 use vortex_layout::layouts::zoned::writer::ZonedStrategy;
 use vortex_utils::aliases::hash_map::HashMap;
@@ -142,7 +142,7 @@ impl WriteStrategyBuilder {
         let validity_strategy = CollectStrategy::new(compress_then_flat);
 
         // Take any field overrides from the builder and apply them to the final strategy.
-        let table_strategy = PathStrategy::new(Arc::new(validity_strategy), Arc::new(repartition))
+        let table_strategy = TableStrategy::new(Arc::new(validity_strategy), Arc::new(repartition))
             .with_field_writers(self.field_writers);
 
         Arc::new(table_strategy)

vortex-file/tests/test_write_table.rs

@@ -24,7 +24,7 @@ use vortex_file::WriteOptionsSessionExt;
 use vortex_io::session::RuntimeSession;
 use vortex_layout::layouts::compressed::CompressingStrategy;
 use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
-use vortex_layout::layouts::path::PathStrategy;
+use vortex_layout::layouts::table::TableStrategy;
 use vortex_layout::session::LayoutSession;
 use vortex_metrics::VortexMetrics;
 use vortex_session::VortexSession;
@@ -66,14 +66,14 @@ async fn test_file_roundtrip() {
     .into_array();
 
     // Create a writer which by default uses the BtrBlocks compressor, but for a.raw column it will
-    // leave it uncompressed.
+    // leave it uncompressed. And for the a.no_dict column disables dictionary compression.
     let default_strategy = Arc::new(CompressingStrategy::new_btrblocks(
         FlatLayoutStrategy::default(),
         false,
     ));
 
     let writer = Arc::new(
-        PathStrategy::new(Arc::new(FlatLayoutStrategy::default()), default_strategy)
+        TableStrategy::new(Arc::new(FlatLayoutStrategy::default()), default_strategy)
             .with_field_writer(field_path!(a.raw), Arc::new(FlatLayoutStrategy::default())),
     );
 

vortex-layout/src/layouts/mod.rs

@@ -18,10 +18,10 @@ pub mod dict;
 pub mod file_stats;
 pub mod flat;
 pub(crate) mod partitioned;
-pub mod path;
 pub mod repartition;
 pub mod row_idx;
 pub mod struct_;
+pub mod table;
 pub mod zoned;
 
 pub type SharedArrayFuture = Shared<BoxFuture<'static, SharedVortexResult<ArrayRef>>>;

vortex-layout/src/layouts/struct_/reader.rs

@@ -417,7 +417,7 @@ mod tests {
     use crate::LayoutRef;
     use crate::LayoutStrategy;
     use crate::layouts::flat::writer::FlatLayoutStrategy;
-    use crate::layouts::path::PathStrategy;
+    use crate::layouts::table::TableStrategy;
     use crate::segments::SegmentSource;
     use crate::segments::TestSegments;
     use crate::sequence::SequenceId;
@@ -430,7 +430,7 @@ mod tests {
 
         let segments = Arc::new(TestSegments::default());
         let (ptr, eof) = SequenceId::root().split();
-        let strategy = PathStrategy::new(
+        let strategy = TableStrategy::new(
             Arc::new(FlatLayoutStrategy::default()),
             Arc::new(FlatLayoutStrategy::default()),
         );
@@ -463,7 +463,7 @@ mod tests {
         let ctx = ArrayContext::empty();
         let segments = Arc::new(TestSegments::default());
         let (ptr, eof) = SequenceId::root().split();
-        let strategy = PathStrategy::new(
+        let strategy = TableStrategy::new(
             Arc::new(FlatLayoutStrategy::default()),
             Arc::new(FlatLayoutStrategy::default()),
         );
@@ -499,7 +499,7 @@ mod tests {
 
         let segments = Arc::new(TestSegments::default());
         let (ptr, eof) = SequenceId::root().split();
-        let strategy = PathStrategy::new(
+        let strategy = TableStrategy::new(
             Arc::new(FlatLayoutStrategy::default()),
             Arc::new(FlatLayoutStrategy::default()),
         );
@@ -540,7 +540,7 @@ mod tests {
         let ctx = ArrayContext::empty();
         let segments = Arc::new(TestSegments::default());
         let (ptr, eof) = SequenceId::root().split();
-        let strategy = PathStrategy::new(
+        let strategy = TableStrategy::new(
             Arc::new(FlatLayoutStrategy::default()),
             Arc::new(FlatLayoutStrategy::default()),
         );

vortex-layout/src/layouts/struct_/writer.rs

@@ -41,9 +41,9 @@ use crate::sequence::SequentialStreamExt;
 /// as its own distinct stream.
 ///
 /// This is now deprecated, users are encouraged to instead use the
-/// [`PathStrategy`][crate::layouts::path::PathStrategy].
+/// [`TableStrategy`][crate::layouts::table::TableStrategy].
 #[derive(Clone)]
-#[deprecated(since = "0.57.0", note = "Use the `PathStrategy` instead.")]
+#[deprecated(since = "0.57.0", note = "Use the `TableStrategy` instead.")]
 pub struct StructStrategy {
     child: Arc<dyn LayoutStrategy>,
     validity: Arc<dyn LayoutStrategy>,

vortex-layout/src/layouts/path.rs vortex-layout/src/layouts/table.rsvortex-layout/src/layouts/path.rs renamed to vortex-layout/src/layouts/table.rs

@@ -44,7 +44,7 @@ use crate::sequence::SequentialStreamExt;
 
 /// A configurable strategy for writing tables with nested field columns, allowing
 /// overrides for specific leaf columns.
-pub struct PathStrategy {
+pub struct TableStrategy {
     /// A set of leaf field overrides, e.g. to force one column to be compact-compressed.
     leaf_writers: HashMap<FieldPath, Arc<dyn LayoutStrategy>>,
     /// The writer for any validity arrays that may be present
@@ -53,7 +53,7 @@ pub struct PathStrategy {
     fallback: Arc<dyn LayoutStrategy>,
 }
 
-impl Default for PathStrategy {
+impl Default for TableStrategy {
     fn default() -> Self {
         let flat = Arc::new(FlatLayoutStrategy::default());
 
@@ -65,7 +65,7 @@ impl Default for PathStrategy {
     }
 }
 
-impl PathStrategy {
+impl TableStrategy {
     /// Create a new writer with the specified write strategies for validity, and for all leaf
     /// fields, with no overrides.
     ///
@@ -76,12 +76,12 @@ impl PathStrategy {
     /// ```
     /// # use std::sync::Arc;
     /// # use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
-    /// # use vortex_layout::layouts::path::PathStrategy;
+    /// # use vortex_layout::layouts::table::TableStrategy;
     ///
     /// // Build a write strategy that does not compress validity or any leaf fields.
     /// let flat = Arc::new(FlatLayoutStrategy::default());
     ///
-    /// let strategy = PathStrategy::new(flat.clone(), flat.clone());
+    /// let strategy = TableStrategy::new(flat.clone(), flat.clone());
     /// ```
     pub fn new(validity: Arc<dyn LayoutStrategy>, fallback: Arc<dyn LayoutStrategy>) -> Self {
         Self {
@@ -101,7 +101,7 @@ impl PathStrategy {
     /// # use vortex_layout::layouts::compact::CompactCompressor;
     /// # use vortex_layout::layouts::compressed::CompressingStrategy;
     /// # use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
-    /// # use vortex_layout::layouts::path::PathStrategy;
+    /// # use vortex_layout::layouts::table::TableStrategy;
     ///
     /// // A strategy for compressing data using the balanced BtrBlocks compressor.
     /// let compress_btrblocks = CompressingStrategy::new_btrblocks(FlatLayoutStrategy::default(), true);
@@ -112,7 +112,7 @@ impl PathStrategy {
     /// // Our combined strategy uses no compression for validity buffers, BtrBlocks compression
     /// // for most columns, and will use ZSTD compression for a nested binary column that we know
     /// // is never filtered in.
-    /// let strategy = PathStrategy::new(
+    /// let strategy = TableStrategy::new(
     ///         Arc::new(FlatLayoutStrategy::default()),
     ///         Arc::new(compress_btrblocks),
     ///     )
@@ -146,7 +146,7 @@ impl PathStrategy {
     }
 }
 
-impl PathStrategy {
+impl TableStrategy {
     // Descend into a subfield for the writer.
     fn descend(&self, field: &Field) -> Self {
         // Start with the existing set of overrides, then only retain the ones that contain
@@ -184,7 +184,7 @@ impl PathStrategy {
 
 /// Specialized strategy for when we exactly know the input schema.
 #[async_trait]
-impl LayoutStrategy for PathStrategy {
+impl LayoutStrategy for TableStrategy {
     async fn write_stream(
         &self,
         ctx: ArrayContext,
@@ -361,7 +361,7 @@ mod tests {
     use vortex_dtype::field_path;
 
     use crate::layouts::flat::writer::FlatLayoutStrategy;
-    use crate::layouts::path::PathStrategy;
+    use crate::layouts::table::TableStrategy;
 
     #[test]
     #[should_panic(
@@ -371,7 +371,7 @@ mod tests {
         let flat = Arc::new(FlatLayoutStrategy::default());
 
         // Success
-        let path = PathStrategy::default().with_field_writer(field_path!(a.b.c), flat.clone());
+        let path = TableStrategy::default().with_field_writer(field_path!(a.b.c), flat.clone());
 
         // Should panic right here.
         let _path = path.with_field_writer(field_path!(a.b), flat);