chore: use internal_err macro in assert_eq_or_internal_err for backtrace

datafusion/catalog-listing/src/helpers.rs

@@ -21,9 +21,7 @@ use std::mem;
 use std::sync::Arc;
 
 use datafusion_catalog::Session;
-use datafusion_common::{
-    assert_or_internal_err, DataFusionError, HashMap, Result, ScalarValue,
-};
+use datafusion_common::{assert_or_internal_err, HashMap, Result, ScalarValue};
 use datafusion_datasource::ListingTableUrl;
 use datafusion_datasource::PartitionedFile;
 use datafusion_expr::{lit, utils, BinaryExpr, Operator};

datafusion/common/src/error.rs

@@ -768,10 +768,10 @@ impl DataFusionErrorBuilder {
 macro_rules! unwrap_or_internal_err {
     ($Value: ident) => {
         $Value.ok_or_else(|| {
-            DataFusionError::Internal(format!(
+            $crate::error::_internal_datafusion_err!(
                 "{} should not be None",
                 stringify!($Value)
-            ))
+            )
         })?
     };
 }
@@ -789,19 +789,19 @@ macro_rules! unwrap_or_internal_err {
 macro_rules! assert_or_internal_err {
     ($cond:expr) => {
         if !$cond {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::error::_internal_datafusion_err!(
                 "Assertion failed: {}",
                 stringify!($cond)
-            )));
+            ));
         }
     };
     ($cond:expr, $($arg:tt)+) => {
         if !$cond {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::error::_internal_datafusion_err!(
                 "Assertion failed: {}: {}",
                 stringify!($cond),
                 format!($($arg)+)
-            )));
+            ));
         }
     };
 }
@@ -821,27 +821,27 @@ macro_rules! assert_eq_or_internal_err {
         let left_val = &$left;
         let right_val = &$right;
         if left_val != right_val {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::error::_internal_datafusion_err!(
                 "Assertion failed: {} == {} (left: {:?}, right: {:?})",
                 stringify!($left),
                 stringify!($right),
                 left_val,
                 right_val
-            )));
+            ));
         }
     }};
     ($left:expr, $right:expr, $($arg:tt)+) => {{
         let left_val = &$left;
         let right_val = &$right;
         if left_val != right_val {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::error::_internal_datafusion_err!(
                 "Assertion failed: {} == {} (left: {:?}, right: {:?}): {}",
                 stringify!($left),
                 stringify!($right),
                 left_val,
                 right_val,
                 format!($($arg)+)
-            )));
+            ));
         }
     }};
 }
@@ -861,27 +861,27 @@ macro_rules! assert_ne_or_internal_err {
         let left_val = &$left;
         let right_val = &$right;
         if left_val == right_val {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::error::_internal_datafusion_err!(
                 "Assertion failed: {} != {} (left: {:?}, right: {:?})",
                 stringify!($left),
                 stringify!($right),
                 left_val,
                 right_val
-            )));
+            ));
         }
     }};
     ($left:expr, $right:expr, $($arg:tt)+) => {{
         let left_val = &$left;
         let right_val = &$right;
         if left_val == right_val {
-            return Err(DataFusionError::Internal(format!(
+            return Err($crate::error::_internal_datafusion_err!(
                 "Assertion failed: {} != {} (left: {:?}, right: {:?}): {}",
                 stringify!($left),
                 stringify!($right),
                 left_val,
                 right_val,
                 format!($($arg)+)
-            )));
+            ));
         }
     }};
 }
@@ -1121,7 +1121,7 @@ mod test {
             ok_result()
         }
 
-        let err = check().unwrap_err();
+        let err = check().unwrap_err().strip_backtrace();
         assert_snapshot!(
             err.to_string(),
             @r"
@@ -1144,7 +1144,7 @@ mod test {
             ok_result()
         }
 
-        let err = check().unwrap_err();
+        let err = check().unwrap_err().strip_backtrace();
         assert_snapshot!(
             err.to_string(),
             @r"
@@ -1168,7 +1168,7 @@ mod test {
             ok_result()
         }
 
-        let err = check().unwrap_err();
+        let err = check().unwrap_err().strip_backtrace();
         assert_snapshot!(
             err.to_string(),
             @r"
@@ -1185,7 +1185,7 @@ mod test {
             ok_result()
         }
 
-        let err = check().unwrap_err();
+        let err = check().unwrap_err().strip_backtrace();
         assert_snapshot!(
             err.to_string(),
             @r"
@@ -1202,7 +1202,7 @@ mod test {
             ok_result()
         }
 
-        let err = check().unwrap_err();
+        let err = check().unwrap_err().strip_backtrace();
         assert_snapshot!(
             err.to_string(),
             @r"

datafusion/common/src/utils/mod.rs

@@ -24,7 +24,7 @@ pub mod string_utils;
 
 use crate::assert_or_internal_err;
 use crate::error::{_exec_datafusion_err, _internal_datafusion_err};
-use crate::{DataFusionError, Result, ScalarValue};
+use crate::{Result, ScalarValue};
 use arrow::array::{
     cast::AsArray, Array, ArrayRef, FixedSizeListArray, LargeListArray, ListArray,
     OffsetSizeTrait,

datafusion/datasource-parquet/src/access_plan.rs

@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use datafusion_common::{assert_eq_or_internal_err, DataFusionError, Result};
+use datafusion_common::{assert_eq_or_internal_err, Result};
 use parquet::arrow::arrow_reader::{RowSelection, RowSelector};
 use parquet::file::metadata::RowGroupMetaData;
 

datafusion/datasource/src/memory.rs

@@ -30,8 +30,7 @@ use crate::source::{DataSource, DataSourceExec};
 use arrow::array::{RecordBatch, RecordBatchOptions};
 use arrow::datatypes::{Schema, SchemaRef};
 use datafusion_common::{
-    assert_or_internal_err, plan_err, project_schema, DataFusionError, Result,
-    ScalarValue,
+    assert_or_internal_err, plan_err, project_schema, Result, ScalarValue,
 };
 use datafusion_execution::TaskContext;
 use datafusion_physical_expr::equivalence::project_orderings;

datafusion/datasource/src/sink.rs

@@ -24,7 +24,7 @@ use std::sync::Arc;
 
 use arrow::array::{ArrayRef, RecordBatch, UInt64Array};
 use arrow::datatypes::{DataType, Field, Schema, SchemaRef};
-use datafusion_common::{assert_eq_or_internal_err, DataFusionError, Result};
+use datafusion_common::{assert_eq_or_internal_err, Result};
 use datafusion_execution::TaskContext;
 use datafusion_physical_expr::{Distribution, EquivalenceProperties};
 use datafusion_physical_expr_common::sort_expr::{LexRequirement, OrderingRequirements};

datafusion/expr-common/src/statistics.rs

@@ -26,7 +26,7 @@ use arrow::datatypes::DataType;
 use datafusion_common::rounding::alter_fp_rounding_mode;
 use datafusion_common::{
     assert_eq_or_internal_err, assert_ne_or_internal_err, assert_or_internal_err,
-    internal_err, not_impl_err, DataFusionError, Result, ScalarValue,
+    internal_err, not_impl_err, Result, ScalarValue,
 };
 
 /// This object defines probabilistic distributions that encode uncertain

datafusion/expr/src/expr_schema.rs

@@ -835,9 +835,7 @@ mod tests {
     use super::*;
     use crate::{and, col, lit, not, or, out_ref_col_with_metadata, when};
 
-    use datafusion_common::{
-        assert_or_internal_err, DFSchema, DataFusionError, ScalarValue,
-    };
+    use datafusion_common::{assert_or_internal_err, DFSchema, ScalarValue};
 
     macro_rules! test_is_expr_nullable {
         ($EXPR_TYPE:ident) => {{

datafusion/expr/src/logical_plan/invariants.rs

@@ -18,7 +18,7 @@
 use datafusion_common::{
     assert_or_internal_err, plan_err,
     tree_node::{TreeNode, TreeNodeRecursion},
-    DFSchemaRef, DataFusionError, Result,
+    DFSchemaRef, Result,
 };
 
 use crate::{

datafusion/expr/src/udf.rs

@@ -26,8 +26,7 @@ use crate::{ColumnarValue, Documentation, Expr, Signature};
 use arrow::datatypes::{DataType, Field, FieldRef};
 use datafusion_common::config::ConfigOptions;
 use datafusion_common::{
-    assert_or_internal_err, not_impl_err, DataFusionError, ExprSchema, Result,
-    ScalarValue,
+    assert_or_internal_err, not_impl_err, ExprSchema, Result, ScalarValue,
 };
 use datafusion_expr_common::dyn_eq::{DynEq, DynHash};
 use datafusion_expr_common::interval_arithmetic::Interval;

datafusion/functions-aggregate/src/array_agg.rs

@@ -32,9 +32,7 @@ use datafusion_common::cast::as_list_array;
 use datafusion_common::utils::{
     compare_rows, get_row_at_idx, take_function_args, SingleRowListArrayBuilder,
 };
-use datafusion_common::{
-    assert_eq_or_internal_err, exec_err, DataFusionError, Result, ScalarValue,
-};
+use datafusion_common::{assert_eq_or_internal_err, exec_err, Result, ScalarValue};
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::utils::format_state_name;
 use datafusion_expr::{

datafusion/functions-aggregate/src/covariance.rs

@@ -24,8 +24,7 @@ use arrow::{
     datatypes::{DataType, Field},
 };
 use datafusion_common::{
-    downcast_value, plan_err, unwrap_or_internal_err, DataFusionError, Result,
-    ScalarValue,
+    downcast_value, plan_err, unwrap_or_internal_err, Result, ScalarValue,
 };
 use datafusion_expr::{
     function::{AccumulatorArgs, StateFieldsArgs},

datafusion/functions-aggregate/src/nth_value.rs

@@ -28,7 +28,7 @@ use arrow::datatypes::{DataType, Field, FieldRef, Fields};
 
 use datafusion_common::utils::{get_row_at_idx, SingleRowListArrayBuilder};
 use datafusion_common::{
-    assert_or_internal_err, exec_err, not_impl_err, DataFusionError, Result, ScalarValue,
+    assert_or_internal_err, exec_err, not_impl_err, Result, ScalarValue,
 };
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};
 use datafusion_expr::utils::format_state_name;

datafusion/functions-aggregate/src/regr.rs

@@ -26,8 +26,7 @@ use arrow::{
     datatypes::Field,
 };
 use datafusion_common::{
-    downcast_value, plan_err, unwrap_or_internal_err, DataFusionError, HashMap, Result,
-    ScalarValue,
+    downcast_value, plan_err, unwrap_or_internal_err, HashMap, Result, ScalarValue,
 };
 use datafusion_doc::aggregate_doc_sections::DOC_SECTION_STATISTICAL;
 use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};

datafusion/functions-nested/src/position.rs

@@ -38,7 +38,7 @@ use datafusion_common::cast::{
     as_generic_list_array, as_int64_array, as_large_list_array, as_list_array,
 };
 use datafusion_common::{
-    assert_or_internal_err, exec_err, utils::take_function_args, DataFusionError, Result,
+    assert_or_internal_err, exec_err, utils::take_function_args, Result,
 };
 use itertools::Itertools;
 

datafusion/functions-nested/src/set_ops.rs

@@ -30,8 +30,7 @@ use arrow::row::{RowConverter, SortField};
 use datafusion_common::cast::{as_large_list_array, as_list_array};
 use datafusion_common::utils::ListCoercion;
 use datafusion_common::{
-    assert_eq_or_internal_err, exec_err, internal_err, utils::take_function_args,
-    DataFusionError, Result,
+    assert_eq_or_internal_err, exec_err, internal_err, utils::take_function_args, Result,
 };
 use datafusion_expr::{
     ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,

datafusion/functions/src/core/greatest.rs

@@ -21,9 +21,7 @@ use arrow::buffer::BooleanBuffer;
 use arrow::compute::kernels::cmp;
 use arrow::compute::SortOptions;
 use arrow::datatypes::DataType;
-use datafusion_common::{
-    assert_eq_or_internal_err, DataFusionError, Result, ScalarValue,
-};
+use datafusion_common::{assert_eq_or_internal_err, Result, ScalarValue};
 use datafusion_doc::Documentation;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};

datafusion/functions/src/core/greatest_least_utils.rs

@@ -18,9 +18,7 @@
 use arrow::array::{Array, ArrayRef, BooleanArray};
 use arrow::compute::kernels::zip::zip;
 use arrow::datatypes::DataType;
-use datafusion_common::{
-    assert_or_internal_err, plan_err, DataFusionError, Result, ScalarValue,
-};
+use datafusion_common::{assert_or_internal_err, plan_err, Result, ScalarValue};
 use datafusion_expr_common::columnar_value::ColumnarValue;
 use datafusion_expr_common::type_coercion::binary::type_union_resolution;
 use std::sync::Arc;

datafusion/functions/src/core/least.rs

@@ -21,9 +21,7 @@ use arrow::buffer::BooleanBuffer;
 use arrow::compute::kernels::cmp;
 use arrow::compute::SortOptions;
 use arrow::datatypes::DataType;
-use datafusion_common::{
-    assert_eq_or_internal_err, DataFusionError, Result, ScalarValue,
-};
+use datafusion_common::{assert_eq_or_internal_err, Result, ScalarValue};
 use datafusion_doc::Documentation;
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};

datafusion/functions/src/math/pi.rs

@@ -19,7 +19,7 @@ use std::any::Any;
 
 use arrow::datatypes::DataType;
 use arrow::datatypes::DataType::Float64;
-use datafusion_common::{assert_or_internal_err, DataFusionError, Result, ScalarValue};
+use datafusion_common::{assert_or_internal_err, Result, ScalarValue};
 use datafusion_expr::sort_properties::{ExprProperties, SortProperties};
 use datafusion_expr::{
     ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,

datafusion/functions/src/math/random.rs

@@ -23,7 +23,7 @@ use arrow::datatypes::DataType;
 use arrow::datatypes::DataType::Float64;
 use rand::{rng, Rng};
 
-use datafusion_common::{assert_or_internal_err, DataFusionError, Result};
+use datafusion_common::{assert_or_internal_err, Result};
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};
 use datafusion_expr::{Documentation, ScalarUDFImpl, Signature, Volatility};
 use datafusion_macros::user_doc;

datafusion/functions/src/string/uuid.rs

@@ -24,7 +24,7 @@ use arrow::datatypes::DataType::Utf8;
 use rand::Rng;
 use uuid::Uuid;
 
-use datafusion_common::{assert_or_internal_err, DataFusionError, Result};
+use datafusion_common::{assert_or_internal_err, Result};
 use datafusion_expr::{ColumnarValue, Documentation, Volatility};
 use datafusion_expr::{ScalarFunctionArgs, ScalarUDFImpl, Signature};
 use datafusion_macros::user_doc;

datafusion/optimizer/src/decorrelate_predicate_subquery.rs

@@ -27,9 +27,7 @@ use crate::{OptimizerConfig, OptimizerRule};
 
 use datafusion_common::alias::AliasGenerator;
 use datafusion_common::tree_node::{Transformed, TransformedResult, TreeNode};
-use datafusion_common::{
-    assert_or_internal_err, plan_err, Column, DataFusionError, Result,
-};
+use datafusion_common::{assert_or_internal_err, plan_err, Column, Result};
 use datafusion_expr::expr::{Exists, InSubquery};
 use datafusion_expr::expr_rewriter::create_col_from_scalar_expr;
 use datafusion_expr::logical_plan::{JoinType, Subquery};

datafusion/optimizer/src/extract_equijoin_predicate.rs

@@ -19,7 +19,7 @@
 use crate::optimizer::ApplyOrder;
 use crate::{OptimizerConfig, OptimizerRule};
 use datafusion_common::tree_node::Transformed;
-use datafusion_common::{assert_or_internal_err, DFSchema, DataFusionError};
+use datafusion_common::{assert_or_internal_err, DFSchema};
 use datafusion_common::{NullEquality, Result};
 use datafusion_expr::utils::split_conjunction_owned;
 use datafusion_expr::utils::{can_hash, find_valid_equijoin_key_pair};

datafusion/optimizer/src/optimize_projections/mod.rs

@@ -26,8 +26,7 @@ use std::sync::Arc;
 
 use datafusion_common::{
     assert_eq_or_internal_err, get_required_group_by_exprs_indices,
-    internal_datafusion_err, internal_err, Column, DFSchema, DataFusionError, HashMap,
-    JoinType, Result,
+    internal_datafusion_err, internal_err, Column, DFSchema, HashMap, JoinType, Result,
 };
 use datafusion_expr::expr::Alias;
 use datafusion_expr::{

datafusion/optimizer/src/push_down_filter.rs

@@ -29,7 +29,7 @@ use datafusion_common::tree_node::{
 };
 use datafusion_common::{
     assert_eq_or_internal_err, assert_or_internal_err, internal_err, plan_err,
-    qualified_name, Column, DFSchema, DataFusionError, Result,
+    qualified_name, Column, DFSchema, Result,
 };
 use datafusion_expr::expr::WindowFunction;
 use datafusion_expr::expr_rewriter::replace_col;