introduce ndarr support

include/questdb/ingress/line_sender.h

@@ -461,6 +461,32 @@ bool line_sender_buffer_column_str(
     line_sender_utf8 value,
     line_sender_error** err_out);
 
+/**
+ * Record a multidimensional array of double for the given column.
+ * The array data must be stored in row-major order (C-style contiguous layout).
+ *
+ * @param[in] buffer Line buffer object.
+ * @param[in] name Column name.
+ * @param[in] rank Number of dimensions of the array.
+ * @param[in] shapes Array of dimension sizes (length = `rank`).
+ *                   Each element must be a positive integer.
+ * @param[in] data_buffer Raw bytes of the array data in little-endian format.
+ *                        Size must be `sizeof(double) * (shapes[0] * ... *
+ *                        shapes[rank-1])`.
+ * @param[in] data_buffer_len Byte length of the data buffer.
+ * @param[out] err_out Set to an error object on failure (if non-NULL).
+ * @return true on success, false on error.
+ */
+LINESENDER_API
+bool line_sender_buffer_column_f64_arr(
+    line_sender_buffer* buffer,
+    line_sender_column_name name,
+    size_t rank,
+    const uint32_t* shapes,
+    const uint8_t* data_buffer,
+    size_t data_buffer_len,
+    line_sender_error** err_out);
+
 /**
  * Record a nanosecond timestamp value for the given column.
  * @param[in] buffer Line buffer object.

include/questdb/ingress/line_sender.hpp

@@ -26,13 +26,15 @@
 
 #include "line_sender.h"
 
+#include <array>
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
 #include <optional>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
+#include <vector>
 #if __cplusplus >= 202002L
 #    include <span>
 #endif
@@ -624,6 +626,39 @@ class line_sender_buffer
         return *this;
     }
 
+    /**
+     * Record a multidimensional double-precision array for the given column.
+     *
+     * @param name    Column name.
+     * @param shape   Array dimensions (e.g., [2,3] for a 2x3 matrix).
+     * @param data    Array data in row-major order. Size must match product of
+     * dimensions.
+     *
+     * @note Data is stored contiguously in row-major (C-style) order.
+     *       Example: shape [2,3] expects 6 elements ordered as:
+     *       [a11, a12, a13, a21, a22, a23]
+     */
+    template <typename T, size_t N>
+    line_sender_buffer& column(
+        column_name_view name,
+        const std::vector<uint32_t>& shape,
+        const std::array<T, N>& data)
+    {
+        static_assert(
+            std::is_same_v<T, double>,
+            "Only double types are supported for arrays");
+        may_init();
+        line_sender_error::wrapped_call(
+            ::line_sender_buffer_column_f64_arr,
+            _impl,
+            name._impl,
+            shape.size(),
+            shape.data(),
+            reinterpret_cast<const uint8_t*>(data.data()),
+            sizeof(double) * N);
+        return *this;
+    }
+
     /**
      * Record a string value for the given column.
      * @param name Column name.

questdb-rs-ffi/src/lib.rs

@@ -24,7 +24,7 @@
 
 #![allow(non_camel_case_types, clippy::missing_safety_doc)]
 
-use libc::{c_char, size_t};
+use libc::{c_char, c_uint, size_t};
 use std::ascii;
 use std::boxed::Box;
 use std::convert::{From, Into};
@@ -35,8 +35,8 @@ use std::str;
 
 use questdb::{
     ingress::{
-        Buffer, CertificateAuthority, ColumnName, Protocol, Sender, SenderBuilder, TableName,
-        TimestampMicros, TimestampNanos,
+        ArrayElement, Buffer, CertificateAuthority, ColumnName, NdArrayView, Protocol, Sender,
+        SenderBuilder, TableName, TimestampMicros, TimestampNanos,
     },
     Error, ErrorCode,
 };
@@ -135,6 +135,15 @@ pub enum line_sender_error_code {
 
     /// Bad configuration.
     line_sender_error_config_error,
+
+    /// Currently, only arrays with a maximum 32 dimensions are supported.
+    line_sender_error_array_large_dim,
+
+    /// ArrayView internal error, such as failure to get the size of a valid dimension.
+    line_sender_error_array_view_internal_error,
+
+    /// Buffer Out Of Memory
+    line_sender_error_buffer_out_of_memory,
 }
 
 impl From<ErrorCode> for line_sender_error_code {
@@ -159,6 +168,15 @@ impl From<ErrorCode> for line_sender_error_code {
                 line_sender_error_code::line_sender_error_server_flush_error
             }
             ErrorCode::ConfigError => line_sender_error_code::line_sender_error_config_error,
+            ErrorCode::ArrayHasTooManyDims => {
+                line_sender_error_code::line_sender_error_array_large_dim
+            }
+            ErrorCode::ArrayViewError => {
+                line_sender_error_code::line_sender_error_array_view_internal_error
+            }
+            ErrorCode::BufferOutOfMemory => {
+                line_sender_error_code::line_sender_error_buffer_out_of_memory
+            }
         }
     }
 }
@@ -291,6 +309,52 @@ impl line_sender_utf8 {
     }
 }
 
+#[derive(Debug, Copy, Clone)]
+struct line_sender_array {
+    dims: size_t,
+    shapes: *const u32,
+    buf_len: size_t,
+    buf: *const u8,
+}
+
+impl<T> NdArrayView<T> for line_sender_array
+where
+    T: ArrayElement,
+{
+    fn ndim(&self) -> usize {
+        self.dims
+    }
+
+    fn dim(&self, index: usize) -> Option<usize> {
+        if index >= self.dims {
+            return None;
+        }
+
+        unsafe {
+            if self.shapes.is_null() {
+                return None;
+            }
+
+            let dim_size = *self.shapes.add(index);
+            Some(dim_size as usize)
+        }
+    }
+
+    fn write_row_major_buf(&self, buff: &mut [u8]) {
+        let elem_size = size_of::<T>();
+        let total_elements: usize = (0..self.dims)
+            .filter_map(|i| <line_sender_array as NdArrayView<T>>::dim(self, i))
+            .product();
+        assert_eq!(
+            self.buf_len,
+            total_elements * elem_size,
+            "Buffer length mismatch"
+        );
+        let bytes = unsafe { slice::from_raw_parts(self.buf, self.buf_len) };
+        buff[..self.buf_len].copy_from_slice(bytes);
+    }
+}
+
 /// An ASCII-safe description of a binary buffer. Trimmed if too long.
 fn describe_buf(buf: &[u8]) -> String {
     let max_len = 100usize;
@@ -804,6 +868,43 @@ pub unsafe extern "C" fn line_sender_buffer_column_str(
     true
 }
 
+/// Record a float multidimensional array value for the given column.
+/// @param[in] buffer Line buffer object.
+/// @param[in] name Column name.
+/// @param[in] rank Array dims.
+/// @param[in] shape Array shapes.
+/// @param[in] data_buffer Array data memory ptr.
+/// @param[in] data_buffer_len Array data memory length.
+/// @param[out] err_out Set on error.
+/// # Safety
+/// - All pointer parameters must be valid and non-null
+/// - shape must point to an array of `rank` integers
+/// - data_buffer must point to a buffer of size `data_buffer_len` bytes
+#[no_mangle]
+pub unsafe extern "C" fn line_sender_buffer_column_f64_arr(
+    buffer: *mut line_sender_buffer,
+    name: line_sender_column_name,
+    rank: size_t,
+    shape: *const c_uint,    // C array of dimension sizes
+    data_buffer: *const u8,  // Raw array data
+    data_buffer_len: size_t, // Total bytes length
+    err_out: *mut *mut line_sender_error,
+) -> bool {
+    let buffer = unwrap_buffer_mut(buffer);
+    let name = name.as_name();
+    let view = line_sender_array {
+        dims: rank,
+        shapes: shape,
+        buf_len: data_buffer_len,
+        buf: data_buffer,
+    };
+    bubble_err_to_c!(
+        err_out,
+        buffer.column_arr::<ColumnName<'_>, line_sender_array, f64>(name, &view)
+    );
+    true
+}
+
 /// Record a nanosecond timestamp value for the given column.
 /// @param[in] buffer Line buffer object.
 /// @param[in] name Column name.

questdb-rs/Cargo.toml

@@ -35,6 +35,7 @@ ureq = { version = "=2.9", optional = true }
 serde_json = { version = "1.0.108", optional = true }
 questdb-confstr = "0.1.0"
 rand = { version = "0.8.5", optional = true }
+ndarray = { version = "0.16.1", optional = true }
 no-panic = { version = "0.1", optional = true }
 
 [target.'cfg(windows)'.dependencies]
@@ -74,7 +75,7 @@ chrono_timestamp = ["chrono"]
 
 [[example]]
 name = "basic"
-required-features = ["chrono_timestamp"]
+required-features = ["chrono_timestamp", "ndarray"]
 
 [[example]]
 name = "auth"
@@ -86,4 +87,4 @@ required-features = ["chrono_timestamp"]
 
 [[example]]
 name = "http"
-required-features = ["ilp-over-http"]
+required-features = ["ilp-over-http", "ndarray"]

questdb-rs/examples/basic.rs

@@ -1,4 +1,5 @@
 use chrono::{TimeZone, Utc};
+use ndarray::arr1;
 use questdb::{
     ingress::{Buffer, Sender, TimestampNanos},
     Result,
@@ -17,6 +18,7 @@ fn main() -> Result<()> {
         .symbol("side", "sell")?
         .column_f64("price", 2615.54)?
         .column_f64("amount", 0.00044)?
+        .column_arr("location", &arr1(&[100.0, 100.1, 100.2]).view())?
         .at(designated_timestamp)?;
 
     //// If you want to pass the current system timestamp, replace with:

questdb-rs/examples/http.rs

@@ -1,3 +1,4 @@
+use ndarray::arr1;
 use questdb::{
     ingress::{Buffer, Sender, TimestampNanos},
     Result,
@@ -12,6 +13,7 @@ fn main() -> Result<()> {
         .symbol("side", "sell")?
         .column_f64("price", 2615.54)?
         .column_f64("amount", 0.00044)?
+        .column_arr("location", &arr1(&[100.0, 100.1, 100.2]).view())?
         .at(TimestampNanos::now())?;
     sender.flush(&mut buffer)?;
     Ok(())

questdb-rs/src/error.rs

@@ -48,6 +48,15 @@ pub enum ErrorCode {
 
     /// Bad configuration.
     ConfigError,
+
+    /// Array has too many dims. Currently, only arrays with a maximum [`crate::ingress::ndarr::MAX_DIMS`] dimensions are supported.
+    ArrayHasTooManyDims,
+
+    /// Array view internal error.
+    ArrayViewError,
+
+    /// Buffer outOfMemory.
+    BufferOutOfMemory,
 }
 
 /// An error that occurred when using QuestDB client library.