consolidating error codes

Author: amunra

include/questdb/ingress/line_sender.h

@@ -78,15 +78,8 @@ typedef 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,
-
-    /**  Write arrayView to sender buffer error. */
-    line_sender_error_array_view_write_to_buffer_error,
+    /** There was an error serializing an array. */
+    line_sender_error_array_error,
 
     /**  Line sender protocol version error. */
     line_sender_error_protocol_version_error,

questdb-rs-ffi/src/lib.rs

@@ -140,14 +140,8 @@ 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,
-
-    /// Write arrayView to sender buffer error.
-    line_sender_error_array_view_write_to_buffer_error,
+    /// There was an error serializing an array.
+    line_sender_error_array_error,
 
     /// Line sender protocol version error.
     line_sender_error_protocol_version_error,
@@ -175,15 +169,7 @@ 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::ArrayWriteToBufferError => {
-                line_sender_error_code::line_sender_error_array_view_write_to_buffer_error
-            }
+            ErrorCode::ArrayError => line_sender_error_code::line_sender_error_array_error,
             ErrorCode::ProtocolVersionError => {
                 line_sender_error_code::line_sender_error_protocol_version_error
             }

questdb-rs-ffi/src/ndarr.rs

@@ -71,7 +71,7 @@ where
     fn dim(&self, index: usize) -> Result<usize, Error> {
         if index >= self.dims {
             return Err(fmt_error!(
-                ArrayViewError,
+                ArrayError,
                 "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                 index,
                 self.dims
@@ -151,13 +151,13 @@ where
     ) -> Result<Self, Error> {
         if dims == 0 {
             return Err(fmt_error!(
-                ArrayViewError,
+                ArrayError,
                 "Zero-dimensional arrays are not supported",
             ));
         }
         if data_len > MAX_ARRAY_BUFFER_SIZE {
             return Err(fmt_error!(
-                ArrayViewError,
+                ArrayError,
                 "Array buffer size too big: {}, maximum: {}",
                 data_len,
                 MAX_ARRAY_BUFFER_SIZE
@@ -168,12 +168,12 @@ where
             .iter()
             .try_fold(std::mem::size_of::<T>(), |acc, &dim| {
                 acc.checked_mul(dim)
-                    .ok_or_else(|| fmt_error!(ArrayViewError, "Array buffer size too big"))
+                    .ok_or_else(|| fmt_error!(ArrayError, "Array buffer size too big"))
             })?;
 
         if size != data_len {
             return Err(fmt_error!(
-                ArrayViewError,
+                ArrayError,
                 "Array buffer length mismatch (actual: {}, expected: {})",
                 data_len,
                 size
@@ -299,7 +299,7 @@ mod tests {
 
             if bytes.len() != expect_size {
                 return Err(fmt_error!(
-                    ArrayWriteToBufferError,
+                    ArrayError,
                     "Array write buffer length mismatch (actual: {}, expected: {})",
                     expect_size,
                     bytes.len()
@@ -308,7 +308,7 @@ mod tests {
 
             if buf.len() < bytes.len() {
                 return Err(fmt_error!(
-                    ArrayWriteToBufferError,
+                    ArrayError,
                     "Buffer capacity {} < required {}",
                     buf.len(),
                     bytes.len()
@@ -334,7 +334,7 @@ mod tests {
         }
         if total_len != expect_size {
             return Err(fmt_error!(
-                ArrayWriteToBufferError,
+                ArrayError,
                 "Array write buffer length mismatch (actual: {}, expected: {})",
                 total_len,
                 expect_size
@@ -445,7 +445,7 @@ mod tests {
             )
         };
         let err = result.unwrap_err();
-        assert_eq!(err.code(), ErrorCode::ArrayViewError);
+        assert_eq!(err.code(), ErrorCode::ArrayError);
         assert!(err.msg().contains("Array buffer size too big"));
         Ok(())
     }
@@ -464,7 +464,7 @@ mod tests {
             )
         };
         let err = result.unwrap_err();
-        assert_eq!(err.code(), ErrorCode::ArrayViewError);
+        assert_eq!(err.code(), ErrorCode::ArrayError);
         assert!(err
             .msg()
             .contains("Array buffer length mismatch (actual: 8, expected: 16)"));
@@ -481,7 +481,7 @@ mod tests {
         };
 
         let err = result.unwrap_err();
-        assert_eq!(err.code(), ErrorCode::ArrayViewError);
+        assert_eq!(err.code(), ErrorCode::ArrayError);
         assert!(err
             .msg()
             .contains("Array buffer length mismatch (actual: 24, expected: 16)"));
@@ -502,7 +502,7 @@ mod tests {
             )
         };
         let err = result.unwrap_err();
-        assert_eq!(err.code(), ErrorCode::ArrayViewError);
+        assert_eq!(err.code(), ErrorCode::ArrayError);
         assert!(err
             .msg()
             .contains("Array buffer length mismatch (actual: 8, expected: 16)"));
@@ -519,7 +519,7 @@ mod tests {
         };
 
         let err = result.unwrap_err();
-        assert_eq!(err.code(), ErrorCode::ArrayViewError);
+        assert_eq!(err.code(), ErrorCode::ArrayError);
         assert!(err
             .msg()
             .contains("Array buffer length mismatch (actual: 24, expected: 16)"));

questdb-rs/src/error.rs

@@ -73,14 +73,8 @@ pub enum ErrorCode {
     /// Bad configuration.
     ConfigError,
 
-    /// Array has too many dims. Currently, only arrays with a maximum [`crate::ingress::MAX_ARRAY_DIMS`] dimensions are supported.
-    ArrayHasTooManyDims,
-
-    /// Array view internal error.
-    ArrayViewError,
-
-    /// Array write to buffer error.
-    ArrayWriteToBufferError,
+    /// There was an error serializing an array.
+    ArrayError,
 
     /// Validate protocol version error.
     ProtocolVersionError,

questdb-rs/src/ingress/mod.rs

@@ -1144,15 +1144,15 @@ impl Buffer {
         let ndim = view.ndim();
         if ndim == 0 {
             return Err(error::fmt!(
-                ArrayViewError,
+                ArrayError,
                 "Zero-dimensional arrays are not supported",
             ));
         }
 
         // check dimension less equal than max dims
         if MAX_ARRAY_DIMS < ndim {
             return Err(error::fmt!(
-                ArrayHasTooManyDims,
+                ArrayError,
                 "Array dimension mismatch: expected at most {} dimensions, but got {}",
                 MAX_ARRAY_DIMS,
                 ndim

questdb-rs/src/ingress/ndarr.rs

@@ -64,7 +64,7 @@ where
 
         if bytes.len() != expect_size {
             return Err(error::fmt!(
-                ArrayWriteToBufferError,
+                ArrayError,
                 "Array write buffer length mismatch (actual: {}, expected: {})",
                 expect_size,
                 bytes.len()
@@ -73,7 +73,7 @@ where
 
         if buf.len() < bytes.len() {
             return Err(error::fmt!(
-                ArrayWriteToBufferError,
+                ArrayError,
                 "Buffer capacity {} < required {}",
                 buf.len(),
                 bytes.len()
@@ -99,7 +99,7 @@ where
     }
     if total_len != expect_size {
         return Err(error::fmt!(
-            ArrayWriteToBufferError,
+            ArrayError,
             "Array write buffer length mismatch (actual: {}, expected: {})",
             total_len,
             expect_size
@@ -119,7 +119,7 @@ where
         let dim = array.dim(dim_index)?;
         if dim > MAX_ARRAY_DIM_LEN {
             return Err(error::fmt!(
-                ArrayViewError,
+                ArrayError,
                 "dimension length out of range: dim {}, dim length {}, max length {}",
                 dim_index,
                 dim,
@@ -132,7 +132,7 @@ where
 
     if size > MAX_ARRAY_BUFFER_SIZE {
         return Err(error::fmt!(
-            ArrayViewError,
+            ArrayError,
             "Array buffer size too big: {}, maximum: {}",
             size,
             MAX_ARRAY_BUFFER_SIZE
@@ -177,7 +177,7 @@ impl<T: ArrayElement> NdArrayView<T> for Vec<T> {
             Ok(self.len())
         } else {
             Err(error::fmt!(
-                    ArrayViewError,
+                    ArrayError,
                     "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                     idx,
                     1
@@ -210,7 +210,7 @@ impl<T: ArrayElement, const N: usize> NdArrayView<T> for [T; N] {
             Ok(N)
         } else {
             Err(error::fmt!(
-                    ArrayViewError,
+                    ArrayError,
                     "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                     idx,
                     1
@@ -244,7 +244,7 @@ impl<T: ArrayElement> NdArrayView<T> for &[T] {
             Ok(self.len())
         } else {
             Err(error::fmt!(
-                    ArrayViewError,
+                    ArrayError,
                     "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                     idx,
                     1
@@ -278,12 +278,12 @@ impl<T: ArrayElement> NdArrayView<T> for Vec<Vec<T>> {
             1 => {
                 let dim1 = self.first().map_or(0, |v| v.len());
                 if self.as_slice().iter().any(|v2| v2.len() != dim1) {
-                    return Err(error::fmt!(ArrayViewError, "Irregular array shape"));
+                    return Err(error::fmt!(ArrayError, "Irregular array shape"));
                 }
                 Ok(dim1)
             }
             _ => Err(error::fmt!(
-                    ArrayViewError,
+                    ArrayError,
                     "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                     idx,
                     2
@@ -316,7 +316,7 @@ impl<T: ArrayElement, const M: usize, const N: usize> NdArrayView<T> for [[T; M]
             0 => Ok(N),
             1 => Ok(M),
             _ => Err(error::fmt!(
-                    ArrayViewError,
+                    ArrayError,
                     "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                     idx,
                     2
@@ -350,7 +350,7 @@ impl<T: ArrayElement, const M: usize> NdArrayView<T> for &[[T; M]] {
             0 => Ok(self.len()),
             1 => Ok(M),
             _ => Err(error::fmt!(
-                    ArrayViewError,
+                    ArrayError,
                     "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                     idx,
                     2
@@ -384,7 +384,7 @@ impl<T: ArrayElement> NdArrayView<T> for Vec<Vec<Vec<T>>> {
             1 => {
                 let dim1 = self.first().map_or(0, |v| v.len());
                 if self.as_slice().iter().any(|v2| v2.len() != dim1) {
-                    return Err(error::fmt!(ArrayViewError, "Irregular array shape"));
+                    return Err(error::fmt!(ArrayError, "Irregular array shape"));
                 }
                 Ok(dim1)
             }
@@ -400,12 +400,12 @@ impl<T: ArrayElement> NdArrayView<T> for Vec<Vec<Vec<T>>> {
                     .flat_map(|v2| v2.as_slice().iter())
                     .any(|v3| v3.len() != dim2)
                 {
-                    return Err(error::fmt!(ArrayViewError, "Irregular array shape"));
+                    return Err(error::fmt!(ArrayError, "Irregular array shape"));
                 }
                 Ok(dim2)
             }
             _ => Err(error::fmt!(
-                    ArrayViewError,
+                    ArrayError,
                     "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                     idx,
                     3
@@ -441,7 +441,7 @@ impl<T: ArrayElement, const M: usize, const N: usize, const L: usize> NdArrayVie
             1 => Ok(N),
             2 => Ok(M),
             _ => Err(error::fmt!(
-                    ArrayViewError,
+                    ArrayError,
                     "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                     idx,
                     3
@@ -475,7 +475,7 @@ impl<T: ArrayElement, const M: usize, const N: usize> NdArrayView<T> for &[[[T;
             1 => Ok(N),
             2 => Ok(M),
             _ => Err(error::fmt!(
-                    ArrayViewError,
+                    ArrayError,
                     "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                     idx,
                     3
@@ -521,7 +521,7 @@ where
             Ok(self.len_of(Axis(index)))
         } else {
             Err(error::fmt!(
-                    ArrayViewError,
+                    ArrayError,
                     "Dimension index out of bounds. Requested axis {}, but array only has {} dimension(s)",
                     index,
                     3

questdb-rs/src/tests/ndarr.rs

@@ -390,7 +390,7 @@ fn test_build_in_2d_vec_irregular_shape() -> TestResult {
     buffer.table("my_test")?;
     let result = buffer.column_arr("arr", &irregular_vec);
     let err = result.unwrap_err();
-    assert_eq!(err.code(), ErrorCode::ArrayViewError);
+    assert_eq!(err.code(), ErrorCode::ArrayError);
     assert!(err.msg().contains("Irregular array shape"));
     Ok(())
 }
@@ -688,12 +688,12 @@ fn test_build_in_3d_vec_irregular_shape() -> TestResult {
     buffer.table("my_test")?;
     let result = buffer.column_arr("arr", &irregular1);
     let err = result.unwrap_err();
-    assert_eq!(err.code(), ErrorCode::ArrayViewError);
+    assert_eq!(err.code(), ErrorCode::ArrayError);
     assert!(err.msg().contains("Irregular array shape"));
 
     let result = buffer.column_arr("arr", &irregular2);
     let err = result.unwrap_err();
-    assert_eq!(err.code(), ErrorCode::ArrayViewError);
+    assert_eq!(err.code(), ErrorCode::ArrayError);
     assert!(err.msg().contains("Irregular array shape"));
     Ok(())
 }
@@ -900,6 +900,6 @@ fn test_buffer_write_ndarray_max_dimensions() -> TestResult {
     let result = buffer.column_arr("invalid", &array_invalid.view());
     assert!(result.is_err());
     let err = result.unwrap_err();
-    assert_eq!(err.code(), ErrorCode::ArrayHasTooManyDims);
+    assert_eq!(err.code(), ErrorCode::ArrayError);
     Ok(())
 }