add non-contiguous minus strides array.

Author: kafka1991

questdb-rs-ffi/src/lib.rs

@@ -879,15 +879,14 @@ pub unsafe extern "C" fn line_sender_buffer_column_f64_arr_c_major(
 ) -> bool {
     let buffer = unwrap_buffer_mut(buffer);
     let name = name.as_name();
-    let view =
-        match CMajorArrayView::<f64>::new(rank, shape, data_buffer, data_buffer_len) {
-            Ok(value) => value,
-            Err(err) => {
-                let err_ptr = Box::into_raw(Box::new(line_sender_error(err)));
-                *err_out = err_ptr;
-                return false;
-            }
-        };
+    let view = match CMajorArrayView::<f64>::new(rank, shape, data_buffer, data_buffer_len) {
+        Ok(value) => value,
+        Err(err) => {
+            let err_ptr = Box::into_raw(Box::new(line_sender_error(err)));
+            *err_out = err_ptr;
+            return false;
+        }
+    };
     bubble_err_to_c!(
         err_out,
         buffer.column_arr::<ColumnName<'_>, CMajorArrayView<'_, f64>, f64>(name, &view)

questdb-rs-ffi/src/ndarr.rs

@@ -149,36 +149,7 @@ where
         data: *const u8,
         data_len: usize,
     ) -> Result<Self, Error> {
-        if dims == 0 {
-            return Err(fmt_error!(
-                ArrayError,
-                "Zero-dimensional arrays are not supported",
-            ));
-        }
-        if data_len > MAX_ARRAY_BUFFER_SIZE {
-            return Err(fmt_error!(
-                ArrayError,
-                "Array buffer size too big: {}, maximum: {}",
-                data_len,
-                MAX_ARRAY_BUFFER_SIZE
-            ));
-        }
-        let shape = slice::from_raw_parts(shape, dims);
-        let size = shape
-            .iter()
-            .try_fold(std::mem::size_of::<T>(), |acc, &dim| {
-                acc.checked_mul(dim)
-                    .ok_or_else(|| fmt_error!(ArrayError, "Array buffer size too big"))
-            })?;
-
-        if size != data_len {
-            return Err(fmt_error!(
-                ArrayError,
-                "Array buffer length mismatch (actual: {}, expected: {})",
-                data_len,
-                size
-            ));
-        }
+        let shape = check_array_shape::<T>(dims, shape, data_len)?;
         let strides = slice::from_raw_parts(strides, dims);
         let mut slice = None;
         if data_len != 0 {
@@ -359,36 +330,7 @@ where
         data: *const u8,
         data_len: usize,
     ) -> Result<Self, Error> {
-        if dims == 0 {
-            return Err(fmt_error!(
-                ArrayError,
-                "Zero-dimensional arrays are not supported",
-            ));
-        }
-        if data_len > MAX_ARRAY_BUFFER_SIZE {
-            return Err(fmt_error!(
-                ArrayError,
-                "Array buffer size too big: {}, maximum: {}",
-                data_len,
-                MAX_ARRAY_BUFFER_SIZE
-            ));
-        }
-        let shape = slice::from_raw_parts(shape, dims);
-        let size = shape
-            .iter()
-            .try_fold(std::mem::size_of::<T>(), |acc, &dim| {
-                acc.checked_mul(dim)
-                    .ok_or_else(|| fmt_error!(ArrayError, "Array buffer size too big"))
-            })?;
-
-        if size != data_len {
-            return Err(fmt_error!(
-                ArrayError,
-                "Array buffer length mismatch (actual: {}, expected: {})",
-                data_len,
-                size
-            ));
-        }
+        let shape = check_array_shape::<T>(dims, shape, data_len)?;
         let mut slice = None;
         if data_len != 0 {
             slice = Some(slice::from_raw_parts(data, data_len));
@@ -402,6 +344,45 @@ where
     }
 }
 
+fn check_array_shape<T>(
+    dims: usize,
+    shape: *const usize,
+    data_len: usize,
+) -> Result<&'static [usize], Error> {
+    if dims == 0 {
+        return Err(fmt_error!(
+            ArrayError,
+            "Zero-dimensional arrays are not supported",
+        ));
+    }
+    if data_len > MAX_ARRAY_BUFFER_SIZE {
+        return Err(fmt_error!(
+            ArrayError,
+            "Array buffer size too big: {}, maximum: {}",
+            data_len,
+            MAX_ARRAY_BUFFER_SIZE
+        ));
+    }
+    let shape = unsafe { slice::from_raw_parts(shape, dims) };
+
+    let size = shape
+        .iter()
+        .try_fold(std::mem::size_of::<T>(), |acc, &dim| {
+            acc.checked_mul(dim)
+                .ok_or_else(|| fmt_error!(ArrayError, "Array buffer size too big"))
+        })?;
+
+    if size != data_len {
+        return Err(fmt_error!(
+            ArrayError,
+            "Array buffer length mismatch (actual: {}, expected: {})",
+            data_len,
+            size
+        ));
+    }
+    Ok(shape)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -909,4 +890,78 @@ mod tests {
         assert_eq!(buf, expected);
         Ok(())
     }
+
+    #[test]
+    fn test_c_major_array_basic() -> TestResult {
+        let test_data = [1.1, 2.2, 3.3, 4.4];
+        let array_view: CMajorArrayView<'_, f64> = unsafe {
+            CMajorArrayView::new(
+                2,
+                [2, 2].as_ptr(),
+                test_data.as_ptr() as *const u8,
+                test_data.len() * 8usize,
+            )
+        }?;
+        let mut buffer = Buffer::new(ProtocolVersion::V2);
+        buffer.table("my_test")?;
+        buffer.column_arr("temperature", &array_view)?;
+        let data = buffer.as_bytes();
+        assert_eq!(&data[0..7], b"my_test");
+        assert_eq!(&data[8..19], b"temperature");
+        assert_eq!(
+            &data[19..24],
+            &[
+                b'=', b'=', 14u8, // ARRAY_BINARY_FORMAT_TYPE
+                10u8, // ArrayColumnTypeTag::Double.into()
+                2u8
+            ]
+        );
+        assert_eq!(
+            &data[24..32],
+            [2i32.to_le_bytes(), 2i32.to_le_bytes()].concat()
+        );
+        assert_eq!(
+            &data[32..64],
+            &[
+                1.1f64.to_ne_bytes(),
+                2.2f64.to_le_bytes(),
+                3.3f64.to_le_bytes(),
+                4.4f64.to_le_bytes(),
+            ]
+            .concat()
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_c_major_empty_array() -> TestResult {
+        let test_data = [];
+        let array_view: CMajorArrayView<'_, f64> = unsafe {
+            CMajorArrayView::new(
+                2,
+                [2, 0].as_ptr(),
+                test_data.as_ptr(),
+                test_data.len() * 8usize,
+            )
+        }?;
+        let mut buffer = Buffer::new(ProtocolVersion::V2);
+        buffer.table("my_test")?;
+        buffer.column_arr("temperature", &array_view)?;
+        let data = buffer.as_bytes();
+        assert_eq!(&data[0..7], b"my_test");
+        assert_eq!(&data[8..19], b"temperature");
+        assert_eq!(
+            &data[19..24],
+            &[
+                b'=', b'=', 14u8, // ARRAY_BINARY_FORMAT_TYPE
+                10u8, // ArrayColumnTypeTag::Double.into()
+                2u8
+            ]
+        );
+        assert_eq!(
+            &data[24..32],
+            [2i32.to_le_bytes(), 0i32.to_le_bytes()].concat()
+        );
+        Ok(())
+    }
 }