wip

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Author: joseph-isaacs

encodings/parquet-variant/src/vtable.rs

@@ -309,7 +309,6 @@ mod tests {
     use vortex_array::Canonical;
     use vortex_array::EqMode;
     use vortex_array::IntoArray;
-    use vortex_array::VTable;
     use vortex_array::VortexSessionExecute;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::arrays::VarBinViewArray;
@@ -400,11 +399,7 @@ mod tests {
 
     #[fixture]
     fn write_strategy() -> Arc<dyn LayoutStrategy> {
-        let mut allowed = vortex_file::ALLOWED_ENCODINGS.clone();
-        allowed.insert(ParquetVariant.id());
-        vortex_file::WriteStrategyBuilder::default()
-            .with_allow_encodings(allowed)
-            .build()
+        vortex_file::WriteStrategyBuilder::default().build()
     }
 
     #[test]

vortex-edition/src/session.rs

@@ -1,8 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-//! The [`EditionSession`] session variable: the per-session registry of editions and
-//! edition inclusions.
+//! Session variables for registered and enabled editions.
 
 use std::any::Any;
 use std::collections::BTreeMap;
@@ -41,6 +40,28 @@ struct Inner {
     inclusions: BTreeMap<Id, EditionInclusion>,
 }
 
+/// The editions enabled for writing in a session.
+///
+/// At most one edition is enabled per family. Enabling a newer or older edition from the
+/// same family replaces the previous selection. This is separate from [`EditionSession`]:
+/// registration describes what a session knows how to reason about, while enabling is the
+/// explicit writer policy.
+#[derive(Clone, Debug, Default)]
+pub struct EnabledEditions {
+    inner: Arc<RwLock<BTreeMap<&'static str, EditionId>>>,
+}
+
+impl EnabledEditions {
+    /// Return the enabled editions, sorted by family.
+    pub fn editions(&self) -> Vec<EditionId> {
+        self.inner.read().values().copied().collect()
+    }
+
+    fn enable(&self, edition: EditionId) {
+        self.inner.write().insert(edition.family, edition);
+    }
+}
+
 impl EditionSession {
     /// Create a session variable with no declarations.
     pub fn empty() -> Self {
@@ -190,12 +211,71 @@ impl SessionVar for EditionSession {
     }
 }
 
+impl SessionVar for EnabledEditions {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
 /// Session data for Vortex editions.
 pub trait EditionSessionExt: SessionExt {
     /// Returns the edition registry.
     fn editions(&self) -> SessionGuard<'_, EditionSession> {
         self.get::<EditionSession>()
     }
+
+    /// Returns the editions enabled for writing.
+    ///
+    /// Accessing this method installs the enabled-editions session variable if it is absent,
+    /// opting the session into edition-gated writing with an initially empty selection.
+    fn enabled_editions(&self) -> SessionGuard<'_, EnabledEditions> {
+        self.get::<EnabledEditions>()
+    }
+
+    /// Register an edition declaration with this session.
+    fn register_edition(&self, declaration: &EditionDeclaration) -> Result<(), EditionError> {
+        self.editions().declare(declaration)
+    }
+
+    /// Enable a registered edition for writing.
+    ///
+    /// Enabling an edition replaces the enabled edition from the same family. An edition
+    /// must be registered first so a typo or unavailable third-party declaration cannot
+    /// silently produce an empty writable set.
+    fn enable_edition(&self, edition: EditionId) -> Result<(), EditionError> {
+        if self.editions().find(&edition).is_none() {
+            return Err(EditionError::new(format!(
+                "cannot enable unregistered edition {edition}"
+            )));
+        }
+        self.enabled_editions().enable(edition);
+        Ok(())
+    }
+
+    /// Resolve the encodings in all enabled editions.
+    ///
+    /// Returns `None` when the enabled-editions variable is absent, which is the explicit
+    /// opt-out used by lower-level sessions. Once the variable is present, an empty enabled
+    /// set resolves to `Some(Vec::new())` and therefore permits no edition encodings.
+    fn enabled_encoding_ids(&self) -> Vec<Id> {
+        let Some(enabled) = self.get_opt::<EnabledEditions>() else {
+            vec![]
+        };
+        let editions = self.editions();
+        let mut ids: Vec<Id> = enabled
+            .editions()
+            .iter()
+            .flat_map(|edition| editions.encodings_in(edition))
+            .map(|inclusion| inclusion.encoding_id)
+            .collect();
+        ids.sort_unstable();
+        ids.dedup();
+        ids
+    }
 }
 
 impl<S: SessionExt> EditionSessionExt for S {}

vortex-file/src/writer.rs

@@ -17,19 +17,22 @@ use futures::pin_mut;
 use futures::select;
 use itertools::Itertools;
 use vortex_array::ArrayContext;
+use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::FieldPath;
 use vortex_array::expr::stats::Stat;
 use vortex_array::iter::ArrayIterator;
 use vortex_array::iter::ArrayIteratorExt;
+use vortex_array::session::ArrayRegistry;
 use vortex_array::session::ArraySessionExt;
 use vortex_array::stats::PRUNING_STATS;
 use vortex_array::stream::ArrayStream;
 use vortex_array::stream::ArrayStreamAdapter;
 use vortex_array::stream::ArrayStreamExt;
 use vortex_array::stream::SendableArrayStream;
 use vortex_buffer::ByteBuffer;
+use vortex_edition::EditionSessionExt;
 use vortex_error::VortexError;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -49,7 +52,6 @@ use vortex_session::SessionExt;
 use vortex_session::VortexSession;
 use vortex_session::registry::ReadContext;
 
-use crate::ALLOWED_ENCODINGS;
 use crate::Footer;
 use crate::MAGIC_BYTES;
 use crate::WriteStrategyBuilder;
@@ -158,14 +160,14 @@ impl VortexWriteOptions {
         mut write: W,
         stream: SendableArrayStream,
     ) -> VortexResult<WriteSummary> {
-        // NOTE(os): Setup an array context that already has all known encodings pre-populated.
-        // This is preferred for now over having an empty context here, because only the
-        // serialised array order is deterministic. The serialisation of arrays are done
-        // parallel and with an empty context they can register their encodings to the context
-        // in different order, changing the written bytes from run to run.
-        let ctx = ArrayContext::new(ALLOWED_ENCODINGS.iter().cloned().sorted().collect())
-            // Configure a registry just to ensure only known encodings are interned.
-            .with_registry(self.session.arrays().registry().clone());
+        // Pre-populate the array context with the registered encodings selected by the enabled
+        // editions. This keeps the serialized ordering deterministic without advertising every
+        // encoding the session happens to know how to read.
+        let array_registry = self.session.arrays().registry().clone();
+        let ctx = ArrayContext::new(self.session.enabled_encoding_ids())
+            // The registry supplies serialization implementations; the layout strategy applies
+            // the enabled-edition write policy before arrays reach serialization.
+            .with_registry(array_registry);
         let dtype = stream.dtype().clone();
 
         let (mut ptr, eof) = SequenceId::root().split();
@@ -532,3 +534,41 @@ impl WriteSummary {
             .collect())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex_array::VTable;
+    use vortex_array::array_session;
+    use vortex_array::arrays::Bool;
+    use vortex_array::arrays::Primitive;
+    use vortex_array::session::ArraySessionExt;
+    use vortex_edition::Edition;
+    use vortex_edition::EditionDeclaration;
+    use vortex_edition::EditionId;
+    use vortex_edition::EditionSession;
+    use vortex_edition::EditionSessionExt;
+
+    use super::initial_array_ids;
+
+    #[test]
+    fn initial_array_ids_are_registered_and_enabled() -> Result<(), vortex_edition::EditionError> {
+        const EDITION: EditionId = EditionId::new("test", 2026, 7, 0);
+        static DECLARATION: EditionDeclaration = EditionDeclaration {
+            edition: Edition {
+                id: EDITION,
+                min_vortex_version: None,
+            },
+            added: &[&"vortex.primitive", &"test.not_registered"],
+        };
+
+        let session = array_session().with::<EditionSession>();
+        session.register_edition(&DECLARATION)?;
+        session.enable_edition(EDITION)?;
+
+        let registry = session.arrays().registry().clone();
+        let ids = initial_array_ids(&session, &registry);
+        assert_eq!(ids, [Primitive.id()]);
+        assert!(!ids.contains(&Bool.id()));
+        Ok(())
+    }
+}

vortex-jni/src/writer.rs

@@ -32,6 +32,7 @@ use jni::sys::jlong;
 use jni::sys::jobject;
 use object_store::ObjectStore;
 use object_store::path::Path as ObjectStorePath;
+use vortex::array::ArrayId;
 use vortex::array::ArrayRef;
 use vortex::array::VTable;
 use vortex::array::scalar::PValue;
@@ -42,6 +43,7 @@ use vortex::array::stream::ArrayStreamAdapter;
 use vortex::dtype::DType;
 use vortex::dtype::Field as DTypeField;
 use vortex::dtype::FieldPath;
+use vortex::editions::EditionSessionExt;
 use vortex::error::VortexError;
 use vortex::error::VortexResult;
 use vortex::error::vortex_err;
@@ -60,6 +62,7 @@ use vortex::io::runtime::Task;
 use vortex::io::session::RuntimeSessionExt;
 use vortex::session::VortexSession;
 use vortex::utils::aliases::hash_map::HashMap;
+use vortex::utils::aliases::hash_set::HashSet;
 use vortex_arrow::ArrowSessionExt;
 use vortex_parquet_variant::ParquetVariant;
 
@@ -108,7 +111,11 @@ fn write_options_for_schema(
         return session.write_options();
     }
 
-    let mut allowed = vortex::file::ALLOWED_ENCODINGS.clone();
+    let mut allowed: HashSet<ArrayId> = session
+        .enabled_encoding_ids()
+        .unwrap_or_default()
+        .into_iter()
+        .collect();
     allowed.insert(ParquetVariant.id());
 
     let strategy = WriteStrategyBuilder::default().with_allow_encodings(allowed);

vortex/src/editions/mod.rs

@@ -3,28 +3,27 @@
 
 //! The Vortex edition declarations.
 //!
-//! [`vortex_edition`] provides the types, the [`crate::editions::EditionSession`] session
-//! variable, and the test harness; the actual declarations live here, one module per edition
-//! (`editions::<family>::<date>`), and are seeded into the default session by
-//! [`crate::editions::register_default_editions`].
+//! [`vortex_edition`] provides the types, session variables, and test harness. The actual
+//! first-party declarations live here, one module per edition. The default session first
+//! registers them with [`register_default_editions`] and then selects its write policy with
+//! [`enable_default_editions`].
 //!
-//! Each edition module declares the edition together with the encodings that join the
-//! family at it; members of earlier editions are inherited and never restated. Correctness
-//! is enforced by unit tests: every edition module calls
-//! [`vortex_edition::test_harness::validate_edition`] once from its `#[cfg(test)]` module,
-//! and the computed set of a frozen edition is pinned by a golden test, so any change to
-//! these declarations that alters a frozen set fails CI. New encodings are staged into the
-//! newest draft edition.
-//!
-//! Note this is currently unused but a future PR will make this public and gate the writer behind
-//! editions.
+//! The default file writer resolves the session's enabled editions at write time. The
+//! facade enables the newest frozen `core` edition, [`CORE_2026_07_0`], and additionally
+//! enables the latest unstable edition when the `unstable_encodings` feature is selected.
 
 pub mod core;
+#[cfg(test)]
+mod tests;
 pub mod unstable;
 
-use vortex_edition::EditionDeclaration;
+pub use vortex_edition::Edition;
+pub use vortex_edition::EditionDeclaration;
+pub use vortex_edition::EditionId;
+pub use vortex_edition::EditionInclusion;
 pub use vortex_edition::EditionSession;
-use vortex_edition::EditionSessionExt;
+pub use vortex_edition::EditionSessionExt;
+pub use vortex_edition::EnabledEditions;
 use vortex_error::VortexExpect;
 use vortex_error::vortex_err;
 use vortex_session::VortexSession;
@@ -38,7 +37,14 @@ pub use self::unstable::UNSTABLE_2026_02_0;
 pub use self::unstable::UNSTABLE_2026_04_0;
 pub use self::unstable::UNSTABLE_2026_06_0;
 
-/// The Vortex editions, each declared together with the encodings it adds.
+/// The `core` edition enabled for writing by the default Vortex session.
+pub const DEFAULT_CORE_EDITION: EditionId = CORE_2026_07_0;
+
+/// The `unstable` edition enabled for writing by the default Vortex session when the
+/// `unstable_encodings` feature is selected.
+pub const DEFAULT_UNSTABLE_EDITION: EditionId = UNSTABLE_2026_06_0;
+
+/// The first-party Vortex edition declarations.
 pub static EDITION_DECLARATIONS: &[&EditionDeclaration] = &[
     &core::v2025_05::DECLARATION,
     &core::v2025_06::DECLARATION,
@@ -52,11 +58,28 @@ pub static EDITION_DECLARATIONS: &[&EditionDeclaration] = &[
 
 /// Register the Vortex edition declarations with the session's [`EditionSession`].
 pub fn register_default_editions(session: &VortexSession) {
-    let editions = session.editions();
     for declaration in EDITION_DECLARATIONS {
-        editions
-            .declare(declaration)
+        session
+            .register_edition(declaration)
             .map_err(|e| vortex_err!("{e}"))
             .vortex_expect("edition declarations are valid");
     }
 }
+
+/// Enable the default Vortex editions for writing.
+///
+/// This selects the newest frozen `core` edition and, when configured, the newest unstable
+/// edition. All declarations must have been registered first with
+/// [`register_default_editions`].
+pub fn enable_default_editions(session: &VortexSession) {
+    session
+        .enable_edition(DEFAULT_CORE_EDITION)
+        .map_err(|e| vortex_err!("{e}"))
+        .vortex_expect("default core edition is registered");
+
+    #[cfg(feature = "unstable_encodings")]
+    session
+        .enable_edition(DEFAULT_UNSTABLE_EDITION)
+        .map_err(|e| vortex_err!("{e}"))
+        .vortex_expect("default unstable edition is registered");
+}