Feature: Add DuckDB conversion for fixed-size lists / ARRAY type (#4590)

Tracking issue: #4372

Relevant DuckDB docs for their ARRAY type:
https://duckdb.org/docs/stable/sql/data_types/array.html

Adds conversion methods and an exporter for fixed-size list type to
DuckDB.

Also adds `vortex-ffi` bindings for fixed-size lists.

---------

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

vortex-duckdb/src/convert/dtype.rs

@@ -99,6 +99,23 @@ impl LogicalType {
         }
     }
 
+    /// Creates a DuckDB fixed-size list logical type with the specified element type and list size.
+    ///
+    /// Note that DuckDB calls what we call a fixed-size list the ARRAY type.
+    fn fixed_size_list_type(element_type: LogicalType, list_size: u32) -> VortexResult<Self> {
+        // SAFETY: We trust that DuckDB correctly gives us a valid pointer or `NULL`.
+        let ptr = unsafe {
+            cpp::duckdb_create_array_type(element_type.as_ptr(), list_size as cpp::idx_t)
+        };
+
+        if ptr.is_null() {
+            vortex_bail!("Failed to create fixed-size list (array) type");
+        }
+
+        // SAFETY: This pointer came directly from DuckDB, and we checked that it was not `NULL`.
+        Ok(unsafe { Self::own(ptr) })
+    }
+
     /// Converts temporal extension types to corresponding DuckDB types.
     ///
     /// # Arguments
@@ -315,8 +332,9 @@ impl TryFrom<&DType> for LogicalType {
                 let element_logical_type = LogicalType::try_from(element_dtype.as_ref())?;
                 return LogicalType::list_type(element_logical_type);
             }
-            DType::FixedSizeList(..) => {
-                unimplemented!("TODO(connor)[FixedSizeList]")
+            DType::FixedSizeList(element_dtype, list_size, _) => {
+                let element_logical_type = LogicalType::try_from(element_dtype.as_ref())?;
+                return LogicalType::fixed_size_list_type(element_logical_type, *list_size);
             }
             DType::Extension(ext_dtype) => {
                 if datetime::is_temporal_ext_type(ext_dtype.id()) {

vortex-duckdb/src/duckdb/logical_type.rs

@@ -31,6 +31,18 @@ impl LogicalType {
         unsafe { Self::own(duckdb_create_list_type(element_dtype.as_ptr())) }
     }
 
+    pub fn new_array(element_dtype: DUCKDB_TYPE, array_size: u32) -> Self {
+        let element_dtype = Self::new(element_dtype);
+
+        // SAFETY: The element_dtype is created by `Self::new` which ensures it is valid.
+        unsafe {
+            Self::own(duckdb_create_array_type(
+                element_dtype.as_ptr(),
+                array_size as idx_t,
+            ))
+        }
+    }
+
     pub fn as_type_id(&self) -> DUCKDB_TYPE {
         unsafe { duckdb_get_type_id(self.as_ptr()) }
     }
@@ -52,6 +64,10 @@ impl LogicalType {
         unsafe { LogicalType::own(duckdb_array_type_child_type(self.as_ptr())) }
     }
 
+    pub fn array_type_array_size(&self) -> idx_t {
+        unsafe { duckdb_array_type_array_size(self.as_ptr()) }
+    }
+
     pub fn list_child_type(&self) -> Self {
         unsafe { LogicalType::own(duckdb_list_type_child_type(self.as_ptr())) }
     }

vortex-duckdb/src/duckdb/vector.rs

@@ -228,6 +228,13 @@ impl Vector {
         unsafe { Self::borrow(cpp::duckdb_list_vector_get_child(self.as_ptr())) }
     }
 
+    pub fn array_vector_get_child(&self) -> Self {
+        // SAFETY: duckdb_array_vector_get_child dereferences the vector pointer which must be
+        // valid and point to an ARRAY type vector. The returned child vector is borrowed and
+        // remains valid as long as the parent vector is valid.
+        unsafe { Self::borrow(cpp::duckdb_array_vector_get_child(self.as_ptr())) }
+    }
+
     pub fn list_vector_set_size(&self, size: u64) -> VortexResult<()> {
         let state = unsafe { cpp::duckdb_list_vector_set_size(self.as_ptr(), size) };
         match state {