refactor(error): remove backtrace, and introduce call-site location for debugging (#1329)

* wip: global replace

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* fix compile

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* fix warnings

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* remove unneeded tests of errors

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* fix ErrorExt trait implementator

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* fix warnings

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* fix format

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

* fix pyo3 tests

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

---------

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

src/datatypes/src/error.rs

@@ -14,8 +14,8 @@
 
 use std::any::Any;
 
-use common_error::prelude::{ErrorCompat, ErrorExt, Snafu, StatusCode};
-use snafu::Backtrace;
+use common_error::prelude::{ErrorExt, Snafu, StatusCode};
+use snafu::Location;
 
 #[derive(Debug, Snafu)]
 #[snafu(visibility(pub))]
@@ -23,44 +23,44 @@ pub enum Error {
     #[snafu(display("Failed to serialize data, source: {}", source))]
     Serialize {
         source: serde_json::Error,
-        backtrace: Backtrace,
+        location: Location,
     },
 
     #[snafu(display("Failed to deserialize data, source: {}, json: {}", source, json))]
     Deserialize {
         source: serde_json::Error,
-        backtrace: Backtrace,
+        location: Location,
         json: String,
     },
 
     #[snafu(display("Failed to convert datafusion type: {}", from))]
-    Conversion { from: String, backtrace: Backtrace },
+    Conversion { from: String, location: Location },
 
     #[snafu(display("Bad array access, Index out of bounds: {}, size: {}", index, size))]
     BadArrayAccess {
         index: usize,
         size: usize,
-        backtrace: Backtrace,
+        location: Location,
     },
 
     #[snafu(display("Unknown vector, {}", msg))]
-    UnknownVector { msg: String, backtrace: Backtrace },
+    UnknownVector { msg: String, location: Location },
 
     #[snafu(display("Unsupported arrow data type, type: {:?}", arrow_type))]
     UnsupportedArrowType {
         arrow_type: arrow::datatypes::DataType,
-        backtrace: Backtrace,
+        location: Location,
     },
 
     #[snafu(display("Unsupported operation: {} for vector: {}", op, vector_type))]
     UnsupportedOperation {
         op: String,
         vector_type: String,
-        backtrace: Backtrace,
+        location: Location,
     },
 
     #[snafu(display("Timestamp column {} not found", name,))]
-    TimestampNotFound { name: String, backtrace: Backtrace },
+    TimestampNotFound { name: String, location: Location },
 
     #[snafu(display(
         "Failed to parse version in schema meta, value: {}, source: {}",
@@ -70,54 +70,45 @@ pub enum Error {
     ParseSchemaVersion {
         value: String,
         source: std::num::ParseIntError,
-        backtrace: Backtrace,
+        location: Location,
     },
 
     #[snafu(display("Invalid timestamp index: {}", index))]
-    InvalidTimestampIndex { index: usize, backtrace: Backtrace },
+    InvalidTimestampIndex { index: usize, location: Location },
 
     #[snafu(display("Duplicate timestamp index, exists: {}, new: {}", exists, new))]
     DuplicateTimestampIndex {
         exists: usize,
         new: usize,
-        backtrace: Backtrace,
+        location: Location,
     },
 
     #[snafu(display("{}", msg))]
-    CastType { msg: String, backtrace: Backtrace },
+    CastType { msg: String, location: Location },
 
     #[snafu(display("Arrow failed to compute, source: {}", source))]
     ArrowCompute {
         source: arrow::error::ArrowError,
-        backtrace: Backtrace,
+        location: Location,
     },
 
     #[snafu(display("Unsupported column default constraint expression: {}", expr))]
-    UnsupportedDefaultExpr { expr: String, backtrace: Backtrace },
+    UnsupportedDefaultExpr { expr: String, location: Location },
 
     #[snafu(display("Default value should not be null for non null column"))]
-    NullDefault { backtrace: Backtrace },
+    NullDefault { location: Location },
 
     #[snafu(display("Incompatible default value type, reason: {}", reason))]
-    DefaultValueType {
-        reason: String,
-        backtrace: Backtrace,
-    },
+    DefaultValueType { reason: String, location: Location },
 
     #[snafu(display("Duplicated metadata for {}", key))]
-    DuplicateMeta { key: String, backtrace: Backtrace },
+    DuplicateMeta { key: String, location: Location },
 
     #[snafu(display("Failed to convert value into scalar value, reason: {}", reason))]
-    ToScalarValue {
-        reason: String,
-        backtrace: Backtrace,
-    },
+    ToScalarValue { reason: String, location: Location },
 
     #[snafu(display("Invalid timestamp precision: {}", precision))]
-    InvalidTimestampPrecision {
-        precision: u64,
-        backtrace: Backtrace,
-    },
+    InvalidTimestampPrecision { precision: u64, location: Location },
 }
 
 impl ErrorExt for Error {
@@ -126,38 +117,9 @@ impl ErrorExt for Error {
         StatusCode::Internal
     }
 
-    fn backtrace_opt(&self) -> Option<&Backtrace> {
-        ErrorCompat::backtrace(self)
-    }
-
     fn as_any(&self) -> &dyn Any {
         self
     }
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashMap;
-
-    use snafu::ResultExt;
-
-    use super::*;
-
-    #[test]
-    pub fn test_error() {
-        let mut map = HashMap::new();
-        map.insert(true, 1);
-        map.insert(false, 2);
-
-        let result = serde_json::to_string(&map).context(SerializeSnafu);
-        assert!(result.is_err(), "serialize result is: {result:?}");
-        let err = serde_json::to_string(&map)
-            .context(SerializeSnafu)
-            .err()
-            .unwrap();
-        assert!(err.backtrace_opt().is_some());
-        assert_eq!(StatusCode::Internal, err.status_code());
-    }
-}