Remove layout strategy generics (#4576)

Makes compile times really really slow. I kept generic constructors for
the nice API

---------

Signed-off-by: Nicholas Gates <nick@nickgates.com>

Author: gatesn

vortex-layout/src/layouts/buffered.rs

@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::collections::VecDeque;
+use std::sync::Arc;
 
 use async_stream::try_stream;
 use async_trait::async_trait;
@@ -16,22 +17,22 @@ use crate::{
 };
 
 #[derive(Clone)]
-pub struct BufferedStrategy<S> {
-    child: S,
+pub struct BufferedStrategy {
+    child: Arc<dyn LayoutStrategy>,
     buffer_size: u64,
 }
 
-impl<S: LayoutStrategy> BufferedStrategy<S> {
-    pub fn new(child: S, buffer_size: u64) -> Self {
-        Self { child, buffer_size }
+impl BufferedStrategy {
+    pub fn new<S: LayoutStrategy>(child: S, buffer_size: u64) -> Self {
+        Self {
+            child: Arc::new(child),
+            buffer_size,
+        }
     }
 }
 
 #[async_trait]
-impl<S> LayoutStrategy for BufferedStrategy<S>
-where
-    S: LayoutStrategy,
-{
+impl LayoutStrategy for BufferedStrategy {
     async fn write_stream(
         &self,
         ctx: &ArrayContext,

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

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use async_trait::async_trait;
 use futures::StreamExt;
 use futures::stream::once;
@@ -16,25 +18,21 @@ use crate::{
 };
 
 #[derive(Clone)]
-pub struct ChunkedLayoutStrategy<S> {
+pub struct ChunkedLayoutStrategy {
     /// The layout strategy for each chunk.
-    pub chunk_strategy: S,
+    pub chunk_strategy: Arc<dyn LayoutStrategy>,
 }
 
-impl<S> ChunkedLayoutStrategy<S>
-where
-    S: LayoutStrategy,
-{
-    pub fn new(chunk_strategy: S) -> Self {
-        Self { chunk_strategy }
+impl ChunkedLayoutStrategy {
+    pub fn new<S: LayoutStrategy>(chunk_strategy: S) -> Self {
+        Self {
+            chunk_strategy: Arc::new(chunk_strategy),
+        }
     }
 }
 
 #[async_trait]
-impl<S> LayoutStrategy for ChunkedLayoutStrategy<S>
-where
-    S: LayoutStrategy,
-{
+impl LayoutStrategy for ChunkedLayoutStrategy {
     async fn write_stream(
         &self,
         ctx: &ArrayContext,

vortex-layout/src/layouts/compressed.rs

@@ -56,28 +56,28 @@ impl CompressorPlugin for crate::layouts::compact::CompactCompressor {
 
 /// A layout writer that compresses chunks.
 #[derive(Clone)]
-pub struct CompressingStrategy<S> {
-    child: S,
+pub struct CompressingStrategy {
+    child: Arc<dyn LayoutStrategy>,
     compressor: Arc<dyn CompressorPlugin>,
     executor: Arc<dyn TaskExecutor>,
     parallelism: usize,
 }
 
-impl<S: LayoutStrategy> CompressingStrategy<S> {
+impl CompressingStrategy {
     /// Create a new writer that uses the BtrBlocks-style cascading compressor to compress chunks.
     ///
     /// This provides a good balance between decoding speed and small file size.
     ///
     /// Set `exclude_int_dict_encoding` to true to prevent dictionary encoding of integer arrays,
     /// which is useful when compressing dictionary codes to avoid recursive dictionary encoding.
-    pub fn new_btrblocks(
+    pub fn new_btrblocks<S: LayoutStrategy>(
         child: S,
         executor: Arc<dyn TaskExecutor>,
         parallelism: usize,
         exclude_int_dict_encoding: bool,
     ) -> Self {
         Self {
-            child,
+            child: Arc::new(child),
             compressor: Arc::new(BtrBlocksCompressor {
                 exclude_int_dict_encoding,
             }),
@@ -94,29 +94,29 @@ impl<S: LayoutStrategy> CompressingStrategy<S> {
     ///
     /// [`CompactCompressor`]: crate::layouts::compact::CompactCompressor
     #[cfg(feature = "zstd")]
-    pub fn new_compact(
+    pub fn new_compact<S: LayoutStrategy>(
         child: S,
         compressor: crate::layouts::compact::CompactCompressor,
         executor: Arc<dyn TaskExecutor>,
         parallelism: usize,
     ) -> Self {
         Self {
-            child,
+            child: Arc::new(child),
             compressor: Arc::new(compressor),
             executor,
             parallelism,
         }
     }
 
     /// Create a new compressor from a plugin interface.
-    pub fn new_opaque<C: CompressorPlugin>(
+    pub fn new_opaque<S: LayoutStrategy, C: CompressorPlugin>(
         child: S,
         compressor: C,
         executor: Arc<dyn TaskExecutor>,
         parallelism: usize,
     ) -> Self {
         Self {
-            child,
+            child: Arc::new(child),
             compressor: Arc::new(compressor),
             executor,
             parallelism,
@@ -125,10 +125,7 @@ impl<S: LayoutStrategy> CompressingStrategy<S> {
 }
 
 #[async_trait]
-impl<S> LayoutStrategy for CompressingStrategy<S>
-where
-    S: LayoutStrategy,
-{
+impl LayoutStrategy for CompressingStrategy {
     async fn write_stream(
         &self,
         ctx: &ArrayContext,

…ex-layout/src/layouts/dict/writer/mod.rs vortex-layout/src/layouts/dict/writer.rsvortex-layout/src/layouts/dict/writer/mod.rs renamed to vortex-layout/src/layouts/dict/writer.rs vortex-layout/src/layouts/dict/writer/mod.rs renamed to vortex-layout/src/layouts/dict/writer.rs

@@ -51,44 +51,34 @@ impl Default for DictLayoutOptions {
 /// encodes chunks into dictionaries. When the dict constraints are hit, a
 /// new dictionary is created.
 #[derive(Clone)]
-pub struct DictStrategy<Codes, Values, Fallback> {
-    codes: Codes,
-    values: Values,
-    fallback: Fallback,
+pub struct DictStrategy {
+    codes: Arc<dyn LayoutStrategy>,
+    values: Arc<dyn LayoutStrategy>,
+    fallback: Arc<dyn LayoutStrategy>,
     options: DictLayoutOptions,
     executor: Arc<dyn TaskExecutor>,
 }
 
-impl<Codes, Values, Fallback> DictStrategy<Codes, Values, Fallback>
-where
-    Codes: LayoutStrategy,
-    Values: LayoutStrategy,
-    Fallback: LayoutStrategy,
-{
-    pub fn new(
+impl DictStrategy {
+    pub fn new<Codes: LayoutStrategy, Values: LayoutStrategy, Fallback: LayoutStrategy>(
         codes: Codes,
         values: Values,
         fallback: Fallback,
         options: DictLayoutOptions,
         executor: Arc<dyn TaskExecutor>,
     ) -> Self {
         Self {
-            codes,
-            values,
-            fallback,
+            codes: Arc::new(codes),
+            values: Arc::new(values),
+            fallback: Arc::new(fallback),
             options,
             executor,
         }
     }
 }
 
 #[async_trait]
-impl<Codes, Values, Fallback> LayoutStrategy for DictStrategy<Codes, Values, Fallback>
-where
-    Codes: LayoutStrategy,
-    Values: LayoutStrategy,
-    Fallback: LayoutStrategy,
-{
+impl LayoutStrategy for DictStrategy {
     async fn write_stream(
         &self,
         ctx: &ArrayContext,

vortex-layout/src/layouts/repartition.rs

@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::collections::VecDeque;
+use std::sync::Arc;
 
 use async_stream::try_stream;
 use async_trait::async_trait;
@@ -29,25 +30,22 @@ pub struct RepartitionWriterOptions {
 /// Each emitted block (except the last) is at least `block_size_minimum` bytes and contains a
 /// multiple of `block_len_multiple` rows.
 #[derive(Clone)]
-pub struct RepartitionStrategy<S> {
-    child: S,
+pub struct RepartitionStrategy {
+    child: Arc<dyn LayoutStrategy>,
     options: RepartitionWriterOptions,
 }
 
-impl<S> RepartitionStrategy<S>
-where
-    S: LayoutStrategy,
-{
-    pub fn new(child: S, options: RepartitionWriterOptions) -> Self {
-        Self { child, options }
+impl RepartitionStrategy {
+    pub fn new<S: LayoutStrategy>(child: S, options: RepartitionWriterOptions) -> Self {
+        Self {
+            child: Arc::new(child),
+            options,
+        }
     }
 }
 
 #[async_trait]
-impl<S> LayoutStrategy for RepartitionStrategy<S>
-where
-    S: LayoutStrategy,
-{
+impl LayoutStrategy for RepartitionStrategy {
     async fn write_stream(
         &self,
         ctx: &ArrayContext,

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

@@ -25,25 +25,21 @@ use crate::{
     SequentialStreamExt,
 };
 
-pub struct StructStrategy<S> {
-    child: S,
+pub struct StructStrategy {
+    child: Arc<dyn LayoutStrategy>,
 }
 
 /// A [`LayoutStrategy`] that splits a StructArray batch into child layout writers
-impl<S> StructStrategy<S>
-where
-    S: LayoutStrategy,
-{
-    pub fn new(child: S) -> Self {
-        Self { child }
+impl StructStrategy {
+    pub fn new<S: LayoutStrategy>(child: S) -> Self {
+        Self {
+            child: Arc::new(child),
+        }
     }
 }
 
 #[async_trait]
-impl<S> LayoutStrategy for StructStrategy<S>
-where
-    S: LayoutStrategy,
-{
+impl LayoutStrategy for StructStrategy {
     async fn write_stream(
         &self,
         ctx: &ArrayContext,

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

@@ -44,39 +44,31 @@ impl Default for ZonedLayoutOptions {
     }
 }
 
-pub struct ZonedStrategy<Child, Stats> {
-    child: Child,
-    stats: Stats,
+pub struct ZonedStrategy {
+    child: Arc<dyn LayoutStrategy>,
+    stats: Arc<dyn LayoutStrategy>,
     options: ZonedLayoutOptions,
     executor: Arc<dyn TaskExecutor>,
 }
 
-impl<Child, Stats> ZonedStrategy<Child, Stats>
-where
-    Child: LayoutStrategy,
-    Stats: LayoutStrategy,
-{
-    pub fn new(
+impl ZonedStrategy {
+    pub fn new<Child: LayoutStrategy, Stats: LayoutStrategy>(
         child: Child,
         stats: Stats,
         options: ZonedLayoutOptions,
         executor: Arc<dyn TaskExecutor>,
     ) -> Self {
         Self {
-            child,
-            stats,
+            child: Arc::new(child),
+            stats: Arc::new(stats),
             options,
             executor,
         }
     }
 }
 
 #[async_trait]
-impl<Child, Stats> LayoutStrategy for ZonedStrategy<Child, Stats>
-where
-    Child: LayoutStrategy,
-    Stats: LayoutStrategy,
-{
+impl LayoutStrategy for ZonedStrategy {
     async fn write_stream(
         &self,
         ctx: &ArrayContext,