ArrayRef

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

Author: gatesn

vortex-array/src/accessor.rs

@@ -6,7 +6,7 @@ pub trait ArrayAccessor<Item: ?Sized> {
     /// Iterate over each element of the array, in-order.
     ///
     /// The function `f` will be passed an [`Iterator`], it can call [`Iterator::next`] on the
-    /// iterator [`crate::DynArray::len`] times. Iterator elements are `Option` types,
+    /// iterator `len` times. Iterator elements are `Option` types,
     /// regardless of the nullability of the underlying array data.
     fn with_iterator<F, R>(&self, f: F) -> R
     where

vortex-array/src/canonical.rs

@@ -55,7 +55,7 @@ use crate::vtable::ArrayView;
 
 /// An enum capturing the default uncompressed encodings for each [Vortex type](DType).
 ///
-/// Any array can be decoded into canonical form via the [`to_canonical`](DynArray::to_canonical)
+/// Any array can be decoded into canonical form via the `to_canonical`
 /// trait method. This is the simplest encoding for a type, and will not be compressed but may
 /// contain compressed child arrays.
 ///

vortex-array/src/serde.rs

@@ -281,7 +281,7 @@ impl ArrayChildren for &[ArrayRef] {
     }
 }
 
-/// [`ArrayParts`] represents a parsed but not-yet-decoded deserialized [`DynArray`].
+/// [`ArrayParts`] represents a parsed but not-yet-decoded deserialized array.
 /// It contains all the information from the serialized form, without anything extra. i.e.
 /// it is missing a [`DType`] and `len`, and the `encoding_id` is not yet resolved to a concrete
 /// vtable.

vortex-array/src/vtable/dyn_.rs

@@ -31,9 +31,6 @@ pub type ArrayId = ArcRef<str>;
 pub type DynVTableRef = Arc<dyn DynVTable>;
 
 /// Dynamically typed vtable trait.
-///
-/// This trait contains the implementation API for Vortex arrays, allowing us to keep the public
-/// [`DynArray`] trait API to a minimum.
 pub trait DynVTable: 'static + Send + Sync + Debug {
     /// Clone this vtable into a `Box<dyn DynVTable>`.
     fn clone_boxed(&self) -> Box<dyn DynVTable>;

vortex-array/src/vtable/typed.rs

@@ -369,6 +369,7 @@ impl<V: VTable> AsRef<ArrayRef> for Array<V> {
 }
 
 impl<V: VTable> IntoArray for Array<V> {
+    #[inline(always)]
     fn into_array(self) -> ArrayRef {
         self.inner
     }

vortex-ffi/cinclude/vortex.h

@@ -499,18 +499,10 @@ typedef struct {
 extern "C" {
 #endif // __cplusplus
 
-/**
- * Clone a borrowed [`vx_array`], returning an owned [`vx_array`].
- *
- *
- * Must be released with [`vx_array_free`].
- */
-const vx_array *vx_array_clone(const vx_array *ptr);
-
 /**
  * Free an owned [`vx_array`] object.
  */
-void vx_array_free(const vx_array *ptr);
+void vx_array_free(vx_array *ptr);
 
 /**
  * Check if array's dtype is nullable.
@@ -559,9 +551,9 @@ size_t vx_array_len(const vx_array *array);
  */
 const vx_dtype *vx_array_dtype(const vx_array *array);
 
-const vx_array *vx_array_get_field(const vx_array *array, size_t index, vx_error **error_out);
+vx_array *vx_array_get_field(const vx_array *array, size_t index, vx_error **error_out);
 
-const vx_array *vx_array_slice(const vx_array *array, size_t start, size_t stop, vx_error **error_out);
+vx_array *vx_array_slice(const vx_array *array, size_t start, size_t stop, vx_error **error_out);
 
 /**
  * Check whether array's element at index is invalid (null) according to the
@@ -578,7 +570,7 @@ size_t vx_array_invalid_count(const vx_array *array, vx_error **error_out);
 /**
  * Create a new array with DTYPE_NULL dtype.
  */
-const vx_array *vx_array_new_null(size_t len);
+vx_array *vx_array_new_null(size_t len);
 
 /**
  * Create a new primitive array from an existing buffer.
@@ -597,11 +589,11 @@ const vx_array *vx_array_new_null(size_t len);
  * vx_array_free(array);
  *
  */
-const vx_array *vx_array_new_primitive(vx_ptype ptype,
-                                       const void *ptr,
-                                       size_t len,
-                                       const vx_validity *validity,
-                                       vx_error **error);
+vx_array *vx_array_new_primitive(vx_ptype ptype,
+                                 const void *ptr,
+                                 size_t len,
+                                 const vx_validity *validity,
+                                 vx_error **error);
 
 uint8_t vx_array_get_u8(const vx_array *array, size_t index);
 
@@ -664,7 +656,7 @@ const vx_binary *vx_array_get_binary(const vx_array *array, uint32_t index);
  * This operation takes constant time as it doesn't execute the underlying
  * array. Executing the underlying array still takes O(n) time.
  */
-const vx_array *vx_array_apply(const vx_array *array, const vx_expression *expression, vx_error **error);
+vx_array *vx_array_apply(const vx_array *array, const vx_expression *expression, vx_error **error);
 
 /**
  * Free an owned [`vx_array_iterator`] object.
@@ -679,7 +671,7 @@ void vx_array_iterator_free(vx_array_iterator *ptr);
  *
  * It is an error to call this function again after the iterator is finished.
  */
-const vx_array *vx_array_iterator_next(vx_array_iterator *iter, vx_error **error_out);
+vx_array *vx_array_iterator_next(vx_array_iterator *iter, vx_error **error_out);
 
 /**
  * Clone a borrowed [`vx_binary`], returning an owned [`vx_binary`].

wasm-test/src/main.rs

@@ -10,7 +10,7 @@ use vortex::compressor::BtrBlocksCompressor;
 
 pub fn main() {
     // Extremely simple test of compression/decompression and a few compute functions.
-    let array = PrimitiveArray::new(buffer![1i32; 1024], Validity::AllValid).to_array();
+    let array = PrimitiveArray::new(buffer![1i32; 1024], Validity::AllValid).into_array();
 
     let compressed = BtrBlocksCompressor::default().compress(&array).unwrap();
     println!("Compressed size: {}", compressed.len());