Minor: clean up error entries (#13521)

comphead · web-flow · commit c0ca4b4e449e · 2024-11-22T07:30:22.000-08:00
* Minor: clean up error entries

* Minor: clean up error entries
diff --git a/datafusion/core/src/dataframe/mod.rs b/datafusion/core/src/dataframe/mod.rs
@@ -50,7 +50,8 @@ use arrow::datatypes::{DataType, Field};
 use arrow_schema::{Schema, SchemaRef};
 use datafusion_common::config::{CsvOptions, JsonOptions};
 use datafusion_common::{
-    plan_err, Column, DFSchema, DataFusionError, ParamValues, SchemaError, UnnestOptions,
+    exec_err, not_impl_err, plan_err, Column, DFSchema, DataFusionError, ParamValues,
+    SchemaError, UnnestOptions,
 };
 use datafusion_expr::dml::InsertOp;
 use datafusion_expr::{case, is_null, lit, SortExpr};
@@ -869,16 +870,16 @@ impl DataFrame {
             for result in describe_record_batch.iter() {
                 let array_ref = match result {
                     Ok(df) => {
-                        let batchs = df.clone().collect().await;
-                        match batchs {
-                            Ok(batchs)
-                                if batchs.len() == 1
-                                    && batchs[0]
+                        let batches = df.clone().collect().await;
+                        match batches {
+                            Ok(batches)
+                                if batches.len() == 1
+                                    && batches[0]
                                         .column_by_name(field.name())
                                         .is_some() =>
                             {
                                 let column =
-                                    batchs[0].column_by_name(field.name()).unwrap();
+                                    batches[0].column_by_name(field.name()).unwrap();
 
                                 if column.data_type().is_null() {
                                     Arc::new(StringArray::from(vec!["null"]))
@@ -901,9 +902,7 @@ impl DataFrame {
                     {
                         Arc::new(StringArray::from(vec!["null"]))
                     }
-                    Err(other_err) => {
-                        panic!("{other_err}")
-                    }
+                    Err(e) => return exec_err!("{}", e),
                 };
                 array_datas.push(array_ref);
             }
@@ -1564,10 +1563,10 @@ impl DataFrame {
         writer_options: Option<CsvOptions>,
     ) -> Result<Vec<RecordBatch>, DataFusionError> {
         if options.insert_op != InsertOp::Append {
-            return Err(DataFusionError::NotImplemented(format!(
+            return not_impl_err!(
                 "{} is not implemented for DataFrame::write_csv.",
                 options.insert_op
-            )));
+            );
         }
 
         let format = if let Some(csv_opts) = writer_options {
@@ -1625,10 +1624,10 @@ impl DataFrame {
         writer_options: Option<JsonOptions>,
     ) -> Result<Vec<RecordBatch>, DataFusionError> {
         if options.insert_op != InsertOp::Append {
-            return Err(DataFusionError::NotImplemented(format!(
+            return not_impl_err!(
                 "{} is not implemented for DataFrame::write_json.",
                 options.insert_op
-            )));
+            );
         }
 
         let format = if let Some(json_opts) = writer_options {
diff --git a/datafusion/core/src/dataframe/parquet.rs b/datafusion/core/src/dataframe/parquet.rs
@@ -26,6 +26,7 @@ use super::{
 };
 
 use datafusion_common::config::TableParquetOptions;
+use datafusion_common::not_impl_err;
 use datafusion_expr::dml::InsertOp;
 
 impl DataFrame {
@@ -59,10 +60,10 @@ impl DataFrame {
         writer_options: Option<TableParquetOptions>,
     ) -> Result<Vec<RecordBatch>, DataFusionError> {
         if options.insert_op != InsertOp::Append {
-            return Err(DataFusionError::NotImplemented(format!(
+            return not_impl_err!(
                 "{} is not implemented for DataFrame::write_parquet.",
                 options.insert_op
-            )));
+            );
         }
 
         let format = if let Some(parquet_opts) = writer_options {
diff --git a/datafusion/core/src/datasource/file_format/avro.rs b/datafusion/core/src/datasource/file_format/avro.rs
@@ -25,8 +25,8 @@ use std::sync::Arc;
 use arrow::datatypes::Schema;
 use arrow::datatypes::SchemaRef;
 use async_trait::async_trait;
+use datafusion_common::internal_err;
 use datafusion_common::parsers::CompressionTypeVariant;
-use datafusion_common::DataFusionError;
 use datafusion_common::GetExt;
 use datafusion_common::DEFAULT_AVRO_EXTENSION;
 use datafusion_physical_expr::PhysicalExpr;
@@ -105,9 +105,7 @@ impl FileFormat for AvroFormat {
         let ext = self.get_ext();
         match file_compression_type.get_variant() {
             CompressionTypeVariant::UNCOMPRESSED => Ok(ext),
-            _ => Err(DataFusionError::Internal(
-                "Avro FileFormat does not support compression.".into(),
-            )),
+            _ => internal_err!("Avro FileFormat does not support compression."),
         }
     }
 
diff --git a/datafusion/core/src/datasource/file_format/parquet.rs b/datafusion/core/src/datasource/file_format/parquet.rs
@@ -49,7 +49,7 @@ use datafusion_common::file_options::parquet_writer::ParquetWriterOptions;
 use datafusion_common::parsers::CompressionTypeVariant;
 use datafusion_common::stats::Precision;
 use datafusion_common::{
-    internal_datafusion_err, not_impl_err, DataFusionError, GetExt,
+    internal_datafusion_err, internal_err, not_impl_err, DataFusionError, GetExt,
     DEFAULT_PARQUET_EXTENSION,
 };
 use datafusion_common_runtime::SpawnedTask;
@@ -323,9 +323,7 @@ impl FileFormat for ParquetFormat {
         let ext = self.get_ext();
         match file_compression_type.get_variant() {
             CompressionTypeVariant::UNCOMPRESSED => Ok(ext),
-            _ => Err(DataFusionError::Internal(
-                "Parquet FileFormat does not support compression.".into(),
-            )),
+            _ => internal_err!("Parquet FileFormat does not support compression."),
         }
     }
 
diff --git a/datafusion/core/src/datasource/file_format/write/demux.rs b/datafusion/core/src/datasource/file_format/write/demux.rs
@@ -37,7 +37,7 @@ use datafusion_common::cast::{
     as_boolean_array, as_date32_array, as_date64_array, as_int32_array, as_int64_array,
     as_string_array, as_string_view_array,
 };
-use datafusion_common::{exec_datafusion_err, DataFusionError};
+use datafusion_common::{exec_datafusion_err, not_impl_err, DataFusionError};
 use datafusion_common_runtime::SpawnedTask;
 use datafusion_execution::TaskContext;
 
@@ -438,10 +438,10 @@ fn compute_partition_keys_by_row<'a>(
                 )
             }
             _ => {
-                return Err(DataFusionError::NotImplemented(format!(
+                return not_impl_err!(
                 "it is not yet supported to write to hive partitions with datatype {}",
                 dtype
-            )))
+            )
             }
         }
 
diff --git a/datafusion/core/src/datasource/physical_plan/file_scan_config.rs b/datafusion/core/src/datasource/physical_plan/file_scan_config.rs
@@ -1165,7 +1165,7 @@ mod tests {
                         })
                         .collect::<Vec<_>>()
                 })
-                .map_err(|e| e.to_string().leak() as &'static str);
+                .map_err(|e| e.strip_backtrace().leak() as &'static str);
 
             assert_eq!(results_by_name, case.expected_result, "{}", case.name);
         }
diff --git a/datafusion/core/src/datasource/physical_plan/statistics.rs b/datafusion/core/src/datasource/physical_plan/statistics.rs
@@ -34,7 +34,7 @@ use arrow::{
 };
 use arrow_array::RecordBatch;
 use arrow_schema::SchemaRef;
-use datafusion_common::{DataFusionError, Result};
+use datafusion_common::{plan_err, DataFusionError, Result};
 use datafusion_physical_expr::{expressions::Column, PhysicalSortExpr};
 use datafusion_physical_expr_common::sort_expr::LexOrdering;
 
@@ -232,9 +232,7 @@ impl MinMaxStatistics {
 
                     // check that sort columns are non-nullable
                     if field.is_nullable() {
-                        return Err(DataFusionError::Plan(
-                            "cannot sort by nullable column".to_string(),
-                        ));
+                        return plan_err!("cannot sort by nullable column");
                     }
 
                     Ok(SortColumn {
diff --git a/datafusion/sql/src/select.rs b/datafusion/sql/src/select.rs
@@ -25,7 +25,7 @@ use crate::utils::{
 };
 
 use datafusion_common::tree_node::{TreeNode, TreeNodeRecursion};
-use datafusion_common::{not_impl_err, plan_err, DataFusionError, Result};
+use datafusion_common::{not_impl_err, plan_err, Result};
 use datafusion_common::{RecursionUnnestOption, UnnestOptions};
 use datafusion_expr::expr::{Alias, PlannedReplaceSelectItem, WildcardOptions};
 use datafusion_expr::expr_rewriter::{
@@ -657,9 +657,7 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
         } = options;
 
         if opt_rename.is_some() {
-            Err(DataFusionError::NotImplemented(
-                "wildcard * with RENAME not supported ".to_string(),
-            ))
+            not_impl_err!("wildcard * with RENAME not supported ")
         } else {
             Ok(())
         }
diff --git a/docs/source/library-user-guide/catalogs.md b/docs/source/library-user-guide/catalogs.md
@@ -73,9 +73,9 @@ impl SchemaProvider for MemorySchemaProvider {
         table: Arc<dyn TableProvider>,
     ) -> Result<Option<Arc<dyn TableProvider>>> {
         if self.table_exist(name.as_str()) {
-            return Err(DataFusionError::Execution(format!(
+            return exec_err!(
                 "The table {name} already exists"
-            )));
+            );
         }
         Ok(self.tables.insert(name, table))
     }

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ use datafusion_common::cast::{`
`37`	`37`	`as_boolean_array, as_date32_array, as_date64_array, as_int32_array, as_int64_array,`
`38`	`38`	`as_string_array, as_string_view_array,`
`39`	`39`	`};`
`40`		`-use datafusion_common::{exec_datafusion_err, DataFusionError};`
	`40`	`+use datafusion_common::{exec_datafusion_err, not_impl_err, DataFusionError};`
`41`	`41`	`use datafusion_common_runtime::SpawnedTask;`
`42`	`42`	`use datafusion_execution::TaskContext;`
`43`	`43`
`@@ -438,10 +438,10 @@ fn compute_partition_keys_by_row<'a>(`
`438`	`438`	`)`
`439`	`439`	`}`
`440`	`440`	`_ => {`
`441`		`- return Err(DataFusionError::NotImplemented(format!(`
	`441`	`+ return not_impl_err!(`
`442`	`442`	`"it is not yet supported to write to hive partitions with datatype {}",`
`443`	`443`	`dtype`
`444`		`- )))`
	`444`	`+ )`
`445`	`445`	`}`
`446`	`446`	`}`
`447`	`447`
Original file line number	Diff line number	Diff line change
`@@ -1165,7 +1165,7 @@ mod tests {`
`1165`	`1165`	`})`
`1166`	`1166`	`.collect::<Vec<_>>()`
`1167`	`1167`	`})`
`1168`		`- .map_err(\|e\| e.to_string().leak() as &'static str);`
	`1168`	`+ .map_err(\|e\| e.strip_backtrace().leak() as &'static str);`
`1169`	`1169`
`1170`	`1170`	`assert_eq!(results_by_name, case.expected_result, "{}", case.name);`
`1171`	`1171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,9 +73,9 @@ impl SchemaProvider for MemorySchemaProvider {`
`73`	`73`	`table: Arc<dyn TableProvider>,`
`74`	`74`	`) -> Result<Option<Arc<dyn TableProvider>>> {`
`75`	`75`	`if self.table_exist(name.as_str()) {`
`76`		`- return Err(DataFusionError::Execution(format!(`
	`76`	`+ return exec_err!(`
`77`	`77`	`"The table {name} already exists"`
`78`		`- )));`
	`78`	`+ );`
`79`	`79`	`}`
`80`	`80`	`Ok(self.tables.insert(name, table))`
`81`	`81`	`}`