Merge remote-tracking branch 'origin/develop' into ji/all-around-cdtx

joseph-isaacs · joseph-isaacs · commit e07ddedf4114 · 2026-04-14T16:59:58.000-04:00
Signed-off-by: Joe Isaacs &lt;joe.isaacs@live.co.uk&gt;
diff --git a/.github/workflows/release-binaries.yml b/.github/workflows/release-binaries.yml
@@ -0,0 +1,60 @@
+name: Release Binaries
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    name: Build ${{ matrix.target }}
+    runs-on: ${{ matrix.runs-on }}
+    timeout-minutes: 120
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: aarch64-apple-darwin
+            runs-on: macos-latest
+            archive: tgz
+          - target: x86_64-apple-darwin
+            runs-on: macos-15-intel
+            archive: tgz
+          - target: aarch64-unknown-linux-gnu
+            runs-on: ubuntu-24.04-arm
+            archive: tgz
+          - target: x86_64-unknown-linux-gnu
+            runs-on: ubuntu-24.04
+            archive: tgz
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - uses: ./.github/actions/setup-rust
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          targets: ${{ matrix.target }}
+          enable-sccache: "false"
+
+      - name: Build release binary
+        run: cargo build --release --package vortex-tui --bin vx --target ${{ matrix.target }}
+
+      - name: Create archive (tgz)
+        if: matrix.archive == 'tgz'
+        run: |
+          cd target/${{ matrix.target }}/release
+          tar -czvf ../../../vx-${{ matrix.target }}.tar.gz vx
+
+      - name: Create archive (zip)
+        if: matrix.archive == 'zip'
+        run: |
+          cd target/${{ matrix.target }}/release
+          zip ../../../vx-${{ matrix.target }}.zip vx.exe
+
+      - name: Upload release asset
+        run: gh release upload "${{ github.event.release.tag_name }}" vx-${{ matrix.target }}.${{ matrix.archive == 'tgz' && 'tar.gz' || 'zip' }}
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/README.md b/README.md
@@ -86,11 +86,14 @@ uv add vortex-data
 For browsing the structure of Vortex files, you can use the `vx` command-line tool.
 
 ```bash
-# Install latest release
-cargo install vortex-tui --locked
+# Install pre-built binary (fast, recommended)
+cargo binstall vortex-tui
 
 # Or build from source
-cargo install --path vortex-tui --locked
+cargo install vortex-tui --locked
+
+# Or run via Python without installing
+uvx --from vortex-data vx --help
 
 # Usage
 vx browse <file>
diff --git a/docs/getting-started/install.md b/docs/getting-started/install.md
@@ -7,17 +7,32 @@ the terminal.
 
 ::::{tab-set}
 
+:::{tab-item} Binstall (recommended)
+```bash
+cargo binstall vortex-tui
+```
+Downloads a pre-built binary. Requires [cargo-binstall](https://github.com/cargo-bins/cargo-binstall).
+:::
+
 :::{tab-item} pip
 ```bash
 pip install vortex-data
 ```
 This also installs the Python library. See the [Python quickstart](python.rst) for library usage.
 :::
 
+:::{tab-item} uvx
+```bash
+uvx --from vortex-data vx --help
+```
+Runs the CLI without installing. Requires [uv](https://docs.astral.sh/uv/).
+:::
+
 :::{tab-item} Cargo
 ```bash
 cargo install vortex-tui
 ```
+Builds from source. This can be slow due to the large dependency tree.
 :::
 
 ::::
diff --git a/encodings/alp/src/alp/plugin.rs b/encodings/alp/src/alp/plugin.rs
@@ -134,7 +134,7 @@ mod tests {
 
         let array = alp_encoded.as_array();
 
-        let metadata = array.metadata(&SESSION)?.unwrap_or_default();
+        let metadata = SESSION.array_serialize(array)?.unwrap();
         let children = array.children();
         let buffers = array
             .buffers()
@@ -183,7 +183,7 @@ mod tests {
 
         let array = alp_encoded.as_array();
 
-        let metadata = array.metadata(&SESSION)?.unwrap_or_default();
+        let metadata = SESSION.array_serialize(array)?.unwrap();
         let children = array.children();
         let buffers = array
             .buffers()
@@ -214,7 +214,7 @@ mod tests {
     fn primitive_array_returns_error() {
         let array = PrimitiveArray::from_iter([1.0f64, 2.0, 3.0]).into_array();
 
-        let metadata = array.metadata(&SESSION).unwrap().unwrap_or_default();
+        let metadata = SESSION.array_serialize(&array).unwrap().unwrap();
         let children = array.children();
         let buffers = array
             .buffers()
diff --git a/encodings/bytebool/src/array.rs b/encodings/bytebool/src/array.rs
@@ -347,7 +347,6 @@ impl From<Vec<Option<bool>>> for ByteBoolData {
 mod tests {
     use vortex_array::ArrayContext;
     use vortex_array::IntoArray;
-    use vortex_array::LEGACY_SESSION;
     use vortex_array::assert_arrays_eq;
     use vortex_array::serde::SerializeOptions;
     use vortex_array::serde::SerializedArray;
@@ -402,7 +401,7 @@ mod tests {
         let serialized = array
             .clone()
             .into_array()
-            .serialize(&ctx, &LEGACY_SESSION, &SerializeOptions::default())
+            .serialize(&ctx, &session, &SerializeOptions::default())
             .unwrap();
 
         let mut concat = ByteBufferMut::empty();
diff --git a/encodings/fastlanes/src/bitpacking/plugin.rs b/encodings/fastlanes/src/bitpacking/plugin.rs
@@ -133,7 +133,7 @@ mod tests {
 
         let array = bitpacked.as_array();
 
-        let metadata = array.metadata(&SESSION)?.unwrap_or_default();
+        let metadata = SESSION.array_serialize(array)?.unwrap();
         let children = array.children();
         let buffers = array
             .buffers()
@@ -182,7 +182,7 @@ mod tests {
 
         let array = bitpacked.as_array();
 
-        let metadata = array.metadata(&SESSION)?.unwrap_or_default();
+        let metadata = SESSION.array_serialize(array)?.unwrap();
         let children = array.children();
         let buffers = array
             .buffers()
@@ -212,7 +212,7 @@ mod tests {
     fn primitive_array_returns_error() -> VortexResult<()> {
         let array = PrimitiveArray::from_iter([1i32, 2, 3]).into_array();
 
-        let metadata = array.metadata(&SESSION)?.unwrap_or_default();
+        let metadata = SESSION.array_serialize(&array)?.unwrap();
         let children = array.children();
         let buffers = array
             .buffers()
diff --git a/encodings/parquet-variant/src/vtable.rs b/encodings/parquet-variant/src/vtable.rs
@@ -244,13 +244,13 @@ mod tests {
     use vortex_array::IntoArray;
     use vortex_array::Precision;
     use vortex_array::arrays::VarBinViewArray;
-    use vortex_array::arrays::Variant;
     use vortex_array::arrays::VariantArray;
     use vortex_array::dtype::DType;
     use vortex_array::dtype::Nullability;
     use vortex_array::dtype::PType;
     use vortex_array::serde::SerializeOptions;
     use vortex_array::serde::SerializedArray;
+    use vortex_array::session::ArraySession;
     use vortex_array::session::ArraySessionExt;
     use vortex_array::validity::Validity;
     use vortex_buffer::BitBuffer;
@@ -261,11 +261,14 @@ mod tests {
 
     use crate::ParquetVariant;
     use crate::array::ParquetVariantArrayExt;
+
     fn roundtrip(array: ArrayRef) -> ArrayRef {
         let dtype = array.dtype().clone();
         let len = array.len();
 
-        let session = VortexSession::empty().with::<vortex_array::session::ArraySession>();
+        let session = VortexSession::empty().with::<ArraySession>();
+        session.arrays().register(ParquetVariant);
+
         let ctx = ArrayContext::empty();
         let serialized = array
             .serialize(&ctx, &session, &SerializeOptions::default())
@@ -276,8 +279,6 @@ mod tests {
             concat.extend_from_slice(buf.as_ref());
         }
         let concat = concat.freeze();
-        session.arrays().register(ParquetVariant);
-        session.arrays().register(Variant);
 
         let parts = SerializedArray::try_from(concat).unwrap();
         parts
diff --git a/encodings/pco/src/lib.rs b/encodings/pco/src/lib.rs
@@ -5,8 +5,6 @@ mod array;
 mod compute;
 mod rules;
 mod slice;
-#[cfg(test)]
-mod test;
 
 pub use array::*;
 
@@ -35,3 +33,6 @@ pub struct PcoMetadata {
     #[prost(message, repeated, tag = "2")]
     pub chunks: Vec<PcoChunkInfo>,
 }
+
+#[cfg(test)]
+mod tests;
diff --git a/encodings/pco/src/tests.rs b/encodings/pco/src/tests.rs
@@ -193,7 +193,7 @@ fn test_serde() -> VortexResult<()> {
     let bytes = pco
         .serialize(
             &context,
-            &LEGACY_SESSION,
+            &SESSION,
             &SerializeOptions {
                 offset: 0,
                 include_padding: true,
diff --git a/encodings/runend/src/arrow.rs b/encodings/runend/src/arrow.rs
@@ -90,6 +90,7 @@ mod tests {
     use vortex_array::search_sorted::SearchSorted;
     use vortex_array::search_sorted::SearchSortedSide;
     use vortex_array::session::ArraySession;
+    use vortex_array::session::ArraySessionExt;
     use vortex_array::validity::Validity;
     use vortex_buffer::Buffer;
     use vortex_buffer::buffer;
@@ -99,8 +100,11 @@ mod tests {
     use crate::RunEnd;
     use crate::ops::find_slice_end_index;
 
-    static SESSION: LazyLock<VortexSession> =
-        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+    static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+        let session = VortexSession::empty().with::<ArraySession>();
+        session.arrays().register(RunEnd);
+        session
+    });
 
     fn decode_run_array<R: RunEndIndexType>(
         array: &RunArray<R>,
diff --git a/encodings/zstd/src/zstd_buffers.rs b/encodings/zstd/src/zstd_buffers.rs
@@ -59,9 +59,9 @@ impl ZstdBuffers {
         session: &VortexSession,
     ) -> VortexResult<ZstdBuffersArray> {
         let encoding_id = array.encoding_id();
-        let metadata = array
-            .metadata(session)?
-            .ok_or_else(|| vortex_err!("Array does not support serialization"))?;
+        let metadata = session
+            .array_serialize(array)?
+            .ok_or_else(|| vortex_err!("[ZstdBuffers]: Array does not support serialization"))?;
         let buffer_handles = array.buffer_handles();
         let children = array.children();
 
diff --git a/vortex-array/public-api.lock b/vortex-array/public-api.lock
@@ -22014,8 +22014,6 @@ pub fn vortex_array::ArrayRef::is_valid(&self, index: usize) -> vortex_error::Vo
 
 pub fn vortex_array::ArrayRef::len(&self) -> usize
 
-pub fn vortex_array::ArrayRef::metadata(&self, session: &vortex_session::VortexSession) -> vortex_error::VortexResult<core::option::Option<alloc::vec::Vec<u8>>>
-
 pub fn vortex_array::ArrayRef::metadata_fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 
 pub fn vortex_array::ArrayRef::named_buffers(&self) -> alloc::vec::Vec<(alloc::string::String, vortex_array::buffer::BufferHandle)>
diff --git a/vortex-array/src/array/erased.rs b/vortex-array/src/array/erased.rs
@@ -15,7 +15,6 @@ use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
 use vortex_mask::Mask;
-use vortex_session::VortexSession;
 
 use crate::AnyCanonical;
 use crate::Array;
@@ -549,11 +548,6 @@ impl ArrayRef {
         self.0.slot_name(self, idx)
     }
 
-    /// Returns the serialized metadata of the array.
-    pub fn metadata(&self, session: &VortexSession) -> VortexResult<Option<Vec<u8>>> {
-        self.0.metadata(self, session)
-    }
-
     /// Formats a human-readable metadata description.
     pub fn metadata_fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.0.metadata_fmt(f)
diff --git a/vortex-array/src/array/mod.rs b/vortex-array/src/array/mod.rs
@@ -13,7 +13,6 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
-use vortex_session::VortexSession;
 use vortex_session::registry::Id;
 
 use crate::ExecutionCtx;
@@ -132,10 +131,6 @@ pub(crate) trait DynArray: 'static + private::Sealed + Send + Sync + Debug {
     /// Returns the name of the slot at the given index.
     fn slot_name(&self, this: &ArrayRef, idx: usize) -> String;
 
-    /// Returns the serialized metadata of the array, or `None` if the array does not
-    /// support serialization.
-    fn metadata(&self, this: &ArrayRef, session: &VortexSession) -> VortexResult<Option<Vec<u8>>>;
-
     /// Formats a human-readable metadata description.
     fn metadata_fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result;
 
@@ -341,11 +336,6 @@ impl<V: VTable> DynArray for ArrayInner<V> {
         V::slot_name(view, idx)
     }
 
-    fn metadata(&self, this: &ArrayRef, session: &VortexSession) -> VortexResult<Option<Vec<u8>>> {
-        let view = unsafe { ArrayView::new_unchecked(this, &self.data) };
-        V::serialize(view, session)
-    }
-
     fn metadata_fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(&self.data, f)
     }
diff --git a/vortex-array/src/arrow/executor/run_end.rs b/vortex-array/src/arrow/executor/run_end.rs
@@ -24,6 +24,7 @@ use crate::IntoArray;
 use crate::arrays::Constant;
 use crate::arrays::ConstantArray;
 use crate::arrow::ArrowArrayExecutor;
+use crate::session::ArraySessionExt;
 
 /// The encoding ID used by `vortex-runend`. We match on this string to avoid a crate dependency.
 const VORTEX_RUNEND_ID: &str = "vortex.runend";
@@ -79,8 +80,9 @@ fn run_end_to_arrow(
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<ArrowArrayRef> {
     let length = array.len();
-    let metadata_bytes = array
-        .metadata(ctx.session())?
+    let metadata_bytes = ctx
+        .session()
+        .array_serialize(&array)?
         .ok_or_else(|| vortex_err!("RunEndArray missing metadata"))?;
     let metadata = RunEndMetadata::decode(&*metadata_bytes)
         .map_err(|e| vortex_err!("Failed to decode RunEndMetadata: {e}"))?;
diff --git a/vortex-array/src/serde.rs b/vortex-array/src/serde.rs
diff --git a/vortex-array/src/session/mod.rs b/vortex-array/src/session/mod.rs
diff --git a/vortex-cuda/src/hybrid_dispatch/mod.rs b/vortex-cuda/src/hybrid_dispatch/mod.rs
diff --git a/vortex-python/src/io.rs b/vortex-python/src/io.rs
diff --git a/vortex-tui/Cargo.toml b/vortex-tui/Cargo.toml
