Apache DataFusion SQL Query Engine
chore: Finish refactor with `assert_or_internal_err!()` (#18790)
Yongting You19865b327182
diff --git a/datafusion/catalog-listing/src/helpers.rs b/datafusion/catalog-listing/src/helpers.rsindex 089457648d..22e7002f90 100644--- a/datafusion/catalog-listing/src/helpers.rs+++ b/datafusion/catalog-listing/src/helpers.rs@@ -21,8 +21,9 @@ use std::mem;use std::sync::Arc;use datafusion_catalog::Session;-use datafusion_common::internal_err;-use datafusion_common::{HashMap, Result, ScalarValue};+use datafusion_common::{+ assert_or_internal_err, DataFusionError, HashMap, Result, ScalarValue,+};use datafusion_datasource::ListingTableUrl;use datafusion_datasource::PartitionedFile;use datafusion_expr::{lit, utils, BinaryExpr, Operator};@@ -386,12 +387,11 @@ pub async fn pruned_partition_list<'a>(.try_filter(|object_meta| futures::future::ready(object_meta.size > 0));if partition_cols.is_empty() {- if !filters.is_empty() {- return internal_err!(- "Got partition filters for unpartitioned table {}",- table_path- );- }+ assert_or_internal_err!(+ filters.is_empty(),+ "Got partition filters for unpartitioned table {}",+ table_path+ );// if no partition col => simply list all the filesOk(objects.map_ok(|object_meta| object_meta.into()).boxed())diff --git a/datafusion/common/src/scalar/mod.rs b/datafusion/common/src/scalar/mod.rsindex fadd2e41ea..787bd78b1d 100644--- a/datafusion/common/src/scalar/mod.rs+++ b/datafusion/common/src/scalar/mod.rs@@ -33,6 +33,7 @@ use std::mem::{size_of, size_of_val};use std::str::FromStr;use std::sync::Arc;+use crate::assert_or_internal_err;use crate::cast::{as_binary_array, as_binary_view_array, as_boolean_array, as_date32_array,as_date64_array, as_decimal128_array, as_decimal256_array, as_decimal32_array,@@ -78,8 +79,8 @@ use arrow::compute::kernels::numeric::{use arrow::datatypes::{i256, validate_decimal_precision_and_scale, ArrowDictionaryKeyType, ArrowNativeType,ArrowTimestampType, DataType, Date32Type, Decimal128Type, Decimal256Type,- Decimal32Type, Decimal64Type, Field, Float32Type, Int16Type, Int32Type, Int64Type,- Int8Type, IntervalDayTime, IntervalDayTimeType, IntervalMonthDayNano,+ Decimal32Type, Decimal64Type, DecimalType, Field, Float32Type, Int16Type, Int32Type,+ Int64Type, Int8Type, IntervalDayTime, IntervalDayTimeType, IntervalMonthDayNano,IntervalMonthDayNanoType, IntervalUnit, IntervalYearMonthType, TimeUnit,TimestampMicrosecondType, TimestampMillisecondType, TimestampNanosecondType,TimestampSecondType, UInt16Type, UInt32Type, UInt64Type, UInt8Type, UnionFields,@@ -1578,12 +1579,10 @@ impl ScalarValue {DataType::Float32 => ScalarValue::Float32(Some(1.0)),DataType::Float64 => ScalarValue::Float64(Some(1.0)),DataType::Decimal32(precision, scale) => {- validate_decimal_precision_and_scale::<Decimal32Type>(+ Self::validate_decimal_or_internal_err::<Decimal32Type>(*precision, *scale,)?;- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match 10_i32.checked_pow(*scale as u32) {Some(value) => {ScalarValue::Decimal32(Some(value), *precision, *scale)@@ -1592,12 +1591,10 @@ impl ScalarValue {}}DataType::Decimal64(precision, scale) => {- validate_decimal_precision_and_scale::<Decimal64Type>(+ Self::validate_decimal_or_internal_err::<Decimal64Type>(*precision, *scale,)?;- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match i64::from(10).checked_pow(*scale as u32) {Some(value) => {ScalarValue::Decimal64(Some(value), *precision, *scale)@@ -1606,12 +1603,10 @@ impl ScalarValue {}}DataType::Decimal128(precision, scale) => {- validate_decimal_precision_and_scale::<Decimal128Type>(+ Self::validate_decimal_or_internal_err::<Decimal128Type>(*precision, *scale,)?;- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match i128::from(10).checked_pow(*scale as u32) {Some(value) => {ScalarValue::Decimal128(Some(value), *precision, *scale)@@ -1620,12 +1615,10 @@ impl ScalarValue {}}DataType::Decimal256(precision, scale) => {- validate_decimal_precision_and_scale::<Decimal256Type>(+ Self::validate_decimal_or_internal_err::<Decimal256Type>(*precision, *scale,)?;- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match i256::from(10).checked_pow(*scale as u32) {Some(value) => {ScalarValue::Decimal256(Some(value), *precision, *scale)@@ -1652,12 +1645,10 @@ impl ScalarValue {DataType::Float32 => ScalarValue::Float32(Some(-1.0)),DataType::Float64 => ScalarValue::Float64(Some(-1.0)),DataType::Decimal32(precision, scale) => {- validate_decimal_precision_and_scale::<Decimal32Type>(+ Self::validate_decimal_or_internal_err::<Decimal32Type>(*precision, *scale,)?;- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match 10_i32.checked_pow(*scale as u32) {Some(value) => {ScalarValue::Decimal32(Some(-value), *precision, *scale)@@ -1666,12 +1657,10 @@ impl ScalarValue {}}DataType::Decimal64(precision, scale) => {- validate_decimal_precision_and_scale::<Decimal64Type>(+ Self::validate_decimal_or_internal_err::<Decimal64Type>(*precision, *scale,)?;- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match i64::from(10).checked_pow(*scale as u32) {Some(value) => {ScalarValue::Decimal64(Some(-value), *precision, *scale)@@ -1680,12 +1669,10 @@ impl ScalarValue {}}DataType::Decimal128(precision, scale) => {- validate_decimal_precision_and_scale::<Decimal128Type>(+ Self::validate_decimal_or_internal_err::<Decimal128Type>(*precision, *scale,)?;- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match i128::from(10).checked_pow(*scale as u32) {Some(value) => {ScalarValue::Decimal128(Some(-value), *precision, *scale)@@ -1694,12 +1681,10 @@ impl ScalarValue {}}DataType::Decimal256(precision, scale) => {- validate_decimal_precision_and_scale::<Decimal256Type>(+ Self::validate_decimal_or_internal_err::<Decimal256Type>(*precision, *scale,)?;- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match i256::from(10).checked_pow(*scale as u32) {Some(value) => {ScalarValue::Decimal256(Some(-value), *precision, *scale)@@ -1729,14 +1714,10 @@ impl ScalarValue {DataType::Float32 => ScalarValue::Float32(Some(10.0)),DataType::Float64 => ScalarValue::Float64(Some(10.0)),DataType::Decimal32(precision, scale) => {- if let Err(err) = validate_decimal_precision_and_scale::<Decimal32Type>(+ Self::validate_decimal_or_internal_err::<Decimal32Type>(*precision, *scale,- ) {- return _internal_err!("Invalid precision and scale {err}");- }- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ )?;+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match 10_i32.checked_pow((*scale + 1) as u32) {Some(value) => {ScalarValue::Decimal32(Some(value), *precision, *scale)@@ -1745,14 +1726,10 @@ impl ScalarValue {}}DataType::Decimal64(precision, scale) => {- if let Err(err) = validate_decimal_precision_and_scale::<Decimal64Type>(+ Self::validate_decimal_or_internal_err::<Decimal64Type>(*precision, *scale,- ) {- return _internal_err!("Invalid precision and scale {err}");- }- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ )?;+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match i64::from(10).checked_pow((*scale + 1) as u32) {Some(value) => {ScalarValue::Decimal64(Some(value), *precision, *scale)@@ -1761,14 +1738,10 @@ impl ScalarValue {}}DataType::Decimal128(precision, scale) => {- if let Err(err) = validate_decimal_precision_and_scale::<Decimal128Type>(+ Self::validate_decimal_or_internal_err::<Decimal128Type>(*precision, *scale,- ) {- return _internal_err!("Invalid precision and scale {err}");- }- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ )?;+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match i128::from(10).checked_pow((*scale + 1) as u32) {Some(value) => {ScalarValue::Decimal128(Some(value), *precision, *scale)@@ -1777,14 +1750,10 @@ impl ScalarValue {}}DataType::Decimal256(precision, scale) => {- if let Err(err) = validate_decimal_precision_and_scale::<Decimal256Type>(+ Self::validate_decimal_or_internal_err::<Decimal256Type>(*precision, *scale,- ) {- return _internal_err!("Invalid precision and scale {err}");- }- if *scale < 0 {- return _internal_err!("Negative scale is not supported");- }+ )?;+ assert_or_internal_err!(*scale >= 0, "Negative scale is not supported");match i256::from(10).checked_pow((*scale + 1) as u32) {Some(value) => {ScalarValue::Decimal256(Some(value), *precision, *scale)@@ -4354,6 +4323,20 @@ impl ScalarValue {_ => None,}}++ /// A thin wrapper on Arrow's validation that throws internal error if validation+ /// fails.+ fn validate_decimal_or_internal_err<T: DecimalType>(+ precision: u8,+ scale: i8,+ ) -> Result<()> {+ validate_decimal_precision_and_scale::<T>(precision, scale).map_err(|err| {+ _internal_datafusion_err!(+ "Decimal precision/scale invariant violated \+ (precision={precision}, scale={scale}): {err}"+ )+ })+ }}/// Compacts the data of an `ArrayData` into a new `ArrayData`.diff --git a/datafusion/common/src/utils/mod.rs b/datafusion/common/src/utils/mod.rsindex 7b145ac3ae..6e7396a7c5 100644--- a/datafusion/common/src/utils/mod.rs+++ b/datafusion/common/src/utils/mod.rs@@ -22,8 +22,9 @@ pub mod memory;pub mod proxy;pub mod string_utils;-use crate::error::{_exec_datafusion_err, _internal_datafusion_err, _internal_err};-use crate::{Result, ScalarValue};+use crate::assert_or_internal_err;+use crate::error::{_exec_datafusion_err, _internal_datafusion_err};+use crate::{DataFusionError, Result, ScalarValue};use arrow::array::{cast::AsArray, Array, ArrayRef, FixedSizeListArray, LargeListArray, ListArray,OffsetSizeTrait,@@ -519,9 +520,7 @@ pub fn arrays_into_list_array(arr: impl IntoIterator<Item = ArrayRef>,) -> Result<ListArray> {let arr = arr.into_iter().collect::<Vec<_>>();- if arr.is_empty() {- return _internal_err!("Cannot wrap empty array into list array");- }+ assert_or_internal_err!(!arr.is_empty(), "Cannot wrap empty array into list array");let lens = arr.iter().map(|x| x.len()).collect::<Vec<_>>();// Assume data type is consistentdiff --git a/datafusion/core/src/physical_planner.rs b/datafusion/core/src/physical_planner.rsindex 6bcc45e9e4..914d411ad6 100644--- a/datafusion/core/src/physical_planner.rs+++ b/datafusion/core/src/physical_planner.rs@@ -1757,11 +1757,11 @@ fn qualify_join_schema_sides(let join_fields = join_schema.fields();// Validate lengths- if join_fields.len() != left_fields.len() + right_fields.len() {- return internal_err!(- "Join schema field count must match left and right field count."- );- }+ assert_eq_or_internal_err!(+ join_fields.len(),+ left_fields.len() + right_fields.len(),+ "Join schema field count must match left and right field count."+ );// Validate field names matchfor (i, (field, expected)) in join_fieldsdiff --git a/datafusion/core/tests/parquet/external_access_plan.rs b/datafusion/core/tests/parquet/external_access_plan.rsindex b35cb6e09c..9022b25356 100644--- a/datafusion/core/tests/parquet/external_access_plan.rs+++ b/datafusion/core/tests/parquet/external_access_plan.rs@@ -257,7 +257,10 @@ async fn bad_selection() {.await.unwrap_err();let err_string = err.to_string();- assert_contains!(&err_string, "Internal error: Invalid ParquetAccessPlan Selection. Row group 0 has 5 rows but selection only specifies 4 rows");+ assert_contains!(+ &err_string,+ "Row group 0 has 5 rows but selection only specifies 4 rows."+ );}/// Return a RowSelection of 1 rows from a row group of 5 rowsdiff --git a/datafusion/core/tests/user_defined/user_defined_plan.rs b/datafusion/core/tests/user_defined/user_defined_plan.rsindex ffe0ba021e..2d0e02719c 100644--- a/datafusion/core/tests/user_defined/user_defined_plan.rs+++ b/datafusion/core/tests/user_defined/user_defined_plan.rs@@ -70,7 +70,7 @@ use arrow::{use datafusion::execution::session_state::SessionStateBuilder;use datafusion::{common::cast::as_int64_array,- common::{arrow_datafusion_err, internal_err, DFSchemaRef},+ common::{arrow_datafusion_err, DFSchemaRef},error::{DataFusionError, Result},execution::{context::{QueryPlanner, SessionState, TaskContext},@@ -91,7 +91,7 @@ use datafusion::{};use datafusion_common::config::ConfigOptions;use datafusion_common::tree_node::{Transformed, TransformedResult, TreeNode};-use datafusion_common::ScalarValue;+use datafusion_common::{assert_eq_or_internal_err, assert_or_internal_err, ScalarValue};use datafusion_expr::{FetchType, InvariantLevel, Projection, SortExpr};use datafusion_optimizer::optimizer::ApplyOrder;use datafusion_optimizer::AnalyzerRule;@@ -585,9 +585,10 @@ impl UserDefinedLogicalNodeCore for TopKPlanNode {kind,}) = self.invariant_mock.clone(){- if should_fail_invariant && check == kind {- return internal_err!("node fails check, such as improper inputs");- }+ assert_or_internal_err!(+ !(should_fail_invariant && check == kind),+ "node fails check, such as improper inputs"+ );}Ok(())}@@ -733,9 +734,11 @@ impl ExecutionPlan for TopKExec {partition: usize,context: Arc<TaskContext>,) -> Result<SendableRecordBatchStream> {- if 0 != partition {- return internal_err!("TopKExec invalid partition {partition}");- }+ assert_eq_or_internal_err!(+ partition,+ 0,+ "TopKExec invalid partition {partition}"+ );Ok(Box::pin(TopKReader {input: self.input.execute(partition, context)?,diff --git a/datafusion/datasource-parquet/src/access_plan.rs b/datafusion/datasource-parquet/src/access_plan.rsindex 0c30f3ff85..295ecea946 100644--- a/datafusion/datasource-parquet/src/access_plan.rs+++ b/datafusion/datasource-parquet/src/access_plan.rs@@ -15,7 +15,7 @@// specific language governing permissions and limitations// under the License.-use datafusion_common::{internal_err, Result};+use datafusion_common::{assert_eq_or_internal_err, DataFusionError, Result};use parquet::arrow::arrow_reader::{RowSelection, RowSelector};use parquet::file::metadata::RowGroupMetaData;@@ -269,13 +269,13 @@ impl ParquetAccessPlan {.sum::<usize>();let row_group_row_count = rg_meta.num_rows();- if rows_in_selection as i64 != row_group_row_count {- return internal_err!(- "Invalid ParquetAccessPlan Selection. Row group {idx} has {row_group_row_count} rows \+ assert_eq_or_internal_err!(+ rows_in_selection as i64,+ row_group_row_count,+ "Invalid ParquetAccessPlan Selection. Row group {idx} has {row_group_row_count} rows \but selection only specifies {rows_in_selection} rows. \Selection: {selection:?}"- );- }+ );}let total_selection: RowSelection = self@@ -482,7 +482,10 @@ mod test {.unwrap_err().to_string();assert_eq!(row_group_indexes, vec![0, 1, 2, 3]);- assert_contains!(err, "Internal error: Invalid ParquetAccessPlan Selection. Row group 1 has 20 rows but selection only specifies 12 rows");+ assert_contains!(+ err,+ "Row group 1 has 20 rows but selection only specifies 12 rows"+ );}#[test]diff --git a/datafusion/optimizer/src/push_down_filter.rs b/datafusion/optimizer/src/push_down_filter.rsindex c8904a55c2..a38cd7a75b 100644--- a/datafusion/optimizer/src/push_down_filter.rs+++ b/datafusion/optimizer/src/push_down_filter.rs@@ -28,8 +28,8 @@ use datafusion_common::tree_node::{Transformed, TransformedResult, TreeNode, TreeNodeRecursion,};use datafusion_common::{- assert_eq_or_internal_err, internal_err, plan_err, qualified_name, Column, DFSchema,- DataFusionError, Result,+ assert_eq_or_internal_err, assert_or_internal_err, internal_err, plan_err,+ qualified_name, Column, DFSchema, DataFusionError, Result,};use datafusion_expr::expr::WindowFunction;use datafusion_expr::expr_rewriter::replace_col;@@ -1372,9 +1372,7 @@ fn insert_below(})?;// make sure we did the actual replacement- if new_child.is_some() {- return internal_err!("node had no inputs");- }+ assert_or_internal_err!(new_child.is_none(), "node had no inputs");Ok(transformed_plan)}diff --git a/datafusion/proto/src/common.rs b/datafusion/proto/src/common.rsindex 2aa12dd350..da4cd942cc 100644--- a/datafusion/proto/src/common.rs+++ b/datafusion/proto/src/common.rs@@ -15,14 +15,16 @@// specific language governing permissions and limitations// under the License.-use datafusion_common::{internal_datafusion_err, internal_err, Result};+use datafusion_common::{+ assert_eq_or_internal_err, internal_datafusion_err, DataFusionError, Result,+};pub(crate) fn str_to_byte(s: &String, description: &str) -> Result<u8> {- if s.len() != 1 {- return internal_err!(- "Invalid CSV {description}: expected single character, got {s}"- );- }+ assert_eq_or_internal_err!(+ s.len(),+ 1,+ "Invalid CSV {description}: expected single character, got {s}"+ );Ok(s.as_bytes()[0])}diff --git a/datafusion/proto/src/logical_plan/mod.rs b/datafusion/proto/src/logical_plan/mod.rsindex 9644c9f69f..84d6688b78 100644--- a/datafusion/proto/src/logical_plan/mod.rs+++ b/datafusion/proto/src/logical_plan/mod.rs@@ -37,8 +37,8 @@ use arrow::datatypes::{DataType, Field, Schema, SchemaBuilder, SchemaRef};use datafusion_catalog::cte_worktable::CteWorkTable;use datafusion_common::file_options::file_type::FileType;use datafusion_common::{- context, internal_datafusion_err, internal_err, not_impl_err, plan_err, Result,- TableReference, ToDFSchema,+ assert_or_internal_err, context, internal_datafusion_err, internal_err, not_impl_err,+ plan_err, DataFusionError, Result, TableReference, ToDFSchema,};use datafusion_datasource::file_format::FileFormat;use datafusion_datasource::file_format::{@@ -776,11 +776,10 @@ impl AsLogicalPlan for LogicalPlanNode {builder.build()}LogicalPlanType::Union(union) => {- if union.inputs.len() < 2 {- return internal_err!(- "Protobuf deserialization error, Union was require at least two input."- );- }+ assert_or_internal_err!(+ union.inputs.len() >= 2,+ "Protobuf deserialization error, Union requires at least two inputs."+ );let (first, rest) = union.inputs.split_first().unwrap();let mut builder = LogicalPlanBuilder::from(first.try_into_logical_plan(ctx, extension_codec)?,diff --git a/datafusion/pruning/src/pruning_predicate.rs b/datafusion/pruning/src/pruning_predicate.rsindex d0c8b52fc4..527a0e0946 100644--- a/datafusion/pruning/src/pruning_predicate.rs+++ b/datafusion/pruning/src/pruning_predicate.rs@@ -36,12 +36,12 @@ use log::{debug, trace};use datafusion_common::error::Result;use datafusion_common::tree_node::TransformedResult;+use datafusion_common::{assert_eq_or_internal_err, Column, DFSchema};use datafusion_common::{- internal_datafusion_err, internal_err, plan_datafusion_err, plan_err,+ internal_datafusion_err, plan_datafusion_err, plan_err,tree_node::{Transformed, TreeNode},- ScalarValue,+ DataFusionError, ScalarValue,};-use datafusion_common::{Column, DFSchema};use datafusion_expr_common::operator::Operator;use datafusion_physical_expr::utils::{collect_columns, Guarantee, LiteralGuarantee};use datafusion_physical_expr::{expressions as phys_expr, PhysicalExprRef};@@ -919,13 +919,13 @@ fn build_statistics_record_batch<S: PruningStatistics + ?Sized>(};let array = array.unwrap_or_else(|| new_null_array(data_type, num_containers));- if num_containers != array.len() {- return internal_err!(- "mismatched statistics length. Expected {}, got {}",- num_containers,- array.len()- );- }+ assert_eq_or_internal_err!(+ num_containers,+ array.len(),+ "mismatched statistics length. Expected {}, got {}",+ num_containers,+ array.len()+ );// cast statistics array to required data type (e.g. parquet// provides timestamp statistics as "Int64")diff --git a/datafusion/spark/src/function/datetime/make_interval.rs b/datafusion/spark/src/function/datetime/make_interval.rsindex 8e3169556b..d510eacb9a 100644--- a/datafusion/spark/src/function/datetime/make_interval.rs+++ b/datafusion/spark/src/function/datetime/make_interval.rs@@ -238,7 +238,9 @@ mod tests {use arrow::array::{Float64Array, Int32Array, IntervalMonthDayNanoArray};use arrow::datatypes::Field;use datafusion_common::config::ConfigOptions;- use datafusion_common::{internal_datafusion_err, internal_err, Result};+ use datafusion_common::{+ assert_eq_or_internal_err, internal_datafusion_err, internal_err, Result,+ };use super::*;fn run_make_interval_month_day_nano(arrs: Vec<ArrayRef>) -> Result<ArrayRef> {@@ -533,34 +535,33 @@ mod tests {.ok_or_else(|| {internal_datafusion_err!("expected IntervalMonthDayNanoArray")})?;- if arr.len() != number_rows {- return internal_err!(- "expected array length {number_rows}, got {}",- arr.len()- );- }+ assert_eq_or_internal_err!(+ arr.len(),+ number_rows,+ "expected array length {number_rows}"+ );for i in 0..number_rows {let iv = arr.value(i);- if (iv.months, iv.days, iv.nanoseconds) != (0, 0, 0) {- return internal_err!(- "row {i}: expected (0,0,0), got ({},{},{})",- iv.months,- iv.days,- iv.nanoseconds- );- }- }- }- ColumnarValue::Scalar(ScalarValue::IntervalMonthDayNano(Some(iv))) => {- if (iv.months, iv.days, iv.nanoseconds) != (0, 0, 0) {- return internal_err!(- "expected scalar 0s, got ({},{},{})",+ assert_eq_or_internal_err!(+ (iv.months, iv.days, iv.nanoseconds),+ (0, 0, 0),+ "row {i}: expected (0,0,0), got ({},{},{})",iv.months,iv.days,iv.nanoseconds);}}+ ColumnarValue::Scalar(ScalarValue::IntervalMonthDayNano(Some(iv))) => {+ assert_eq_or_internal_err!(+ (iv.months, iv.days, iv.nanoseconds),+ (0, 0, 0),+ "expected scalar 0s, got ({},{},{})",+ iv.months,+ iv.days,+ iv.nanoseconds+ );+ }other => {return internal_err!("expected Array or Scalar IntervalMonthDayNano, got {other:?}"diff --git a/datafusion/spark/src/function/math/modulus.rs b/datafusion/spark/src/function/math/modulus.rsindex b894c8cad5..aa66b179e2 100644--- a/datafusion/spark/src/function/math/modulus.rs+++ b/datafusion/spark/src/function/math/modulus.rs@@ -19,7 +19,7 @@ use arrow::compute::kernels::numeric::add;use arrow::compute::kernels::{cmp::lt, numeric::rem, zip::zip};use arrow::datatypes::DataType;use datafusion_common::{- assert_eq_or_internal_err, internal_err, DataFusionError, Result, ScalarValue,+ assert_eq_or_internal_err, DataFusionError, Result, ScalarValue,};use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility,@@ -85,9 +85,11 @@ impl ScalarUDFImpl for SparkMod {}fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {- if arg_types.len() != 2 {- return internal_err!("mod expects exactly two arguments");- }+ assert_eq_or_internal_err!(+ arg_types.len(),+ 2,+ "mod expects exactly two arguments"+ );// Return the same type as the first argument for simplicity// Arrow's rem function handles type promotion internally@@ -133,9 +135,11 @@ impl ScalarUDFImpl for SparkPmod {}fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {- if arg_types.len() != 2 {- return internal_err!("pmod expects exactly two arguments");- }+ assert_eq_or_internal_err!(+ arg_types.len(),+ 2,+ "pmod expects exactly two arguments"+ );// Return the same type as the first argument for simplicity// Arrow's rem function handles type promotion internallydiff --git a/datafusion/spark/src/function/math/rint.rs b/datafusion/spark/src/function/math/rint.rsindex aae5455df0..40dac9cb31 100644--- a/datafusion/spark/src/function/math/rint.rs+++ b/datafusion/spark/src/function/math/rint.rs@@ -84,9 +84,7 @@ impl ScalarUDFImpl for SparkRint {}pub fn spark_rint(args: &[ArrayRef]) -> Result<ArrayRef> {- if args.len() != 1 {- assert_eq_or_internal_err!(args.len(), 1, "`rint` expects exactly one argument");- }+ assert_eq_or_internal_err!(args.len(), 1, "`rint` expects exactly one argument");let array: &dyn Array = args[0].as_ref();match args[0].data_type() {