Apache DataFusion SQL Query Engine
chore: Format examples in doc strings - common (#18336)
Yu-Chuan Hung5d2084b31cc1
diff --git a/datafusion/common/src/config.rs b/datafusion/common/src/config.rsindex 10199db1a1..bc321b227e 100644--- a/datafusion/common/src/config.rs+++ b/datafusion/common/src/config.rs@@ -57,7 +57,7 @@ use std::sync::Arc;/// /// Field 3 doc/// field3: Option<usize>, default = None/// }-///}+/// }/// ```////// Will generate@@ -1326,36 +1326,35 @@ impl ConfigOptions {/// # Example/// ```/// use datafusion_common::{-/// config::ConfigExtension, extensions_options,-/// config::ConfigOptions,+/// config::ConfigExtension, config::ConfigOptions, extensions_options,/// };-/// // Define a new configuration struct using the `extensions_options` macro-/// extensions_options! {-/// /// My own config options.-/// pub struct MyConfig {-/// /// Should "foo" be replaced by "bar"?-/// pub foo_to_bar: bool, default = true+/// // Define a new configuration struct using the `extensions_options` macro+/// extensions_options! {+/// /// My own config options.+/// pub struct MyConfig {+/// /// Should "foo" be replaced by "bar"?+/// pub foo_to_bar: bool, default = true///-/// /// How many "baz" should be created?-/// pub baz_count: usize, default = 1337-/// }-/// }+/// /// How many "baz" should be created?+/// pub baz_count: usize, default = 1337+/// }+/// }///-/// impl ConfigExtension for MyConfig {+/// impl ConfigExtension for MyConfig {/// const PREFIX: &'static str = "my_config";-/// }+/// }///-/// // set up config struct and register extension-/// let mut config = ConfigOptions::default();-/// config.extensions.insert(MyConfig::default());+/// // set up config struct and register extension+/// let mut config = ConfigOptions::default();+/// config.extensions.insert(MyConfig::default());///-/// // overwrite config default-/// config.set("my_config.baz_count", "42").unwrap();+/// // overwrite config default+/// config.set("my_config.baz_count", "42").unwrap();///-/// // check config state-/// let my_config = config.extensions.get::<MyConfig>().unwrap();-/// assert!(my_config.foo_to_bar,);-/// assert_eq!(my_config.baz_count, 42,);+/// // check config state+/// let my_config = config.extensions.get::<MyConfig>().unwrap();+/// assert!(my_config.foo_to_bar,);+/// assert_eq!(my_config.baz_count, 42,);/// ```////// # Note:diff --git a/datafusion/common/src/datatype.rs b/datafusion/common/src/datatype.rsindex 544ec0c246..65f6395211 100644--- a/datafusion/common/src/datatype.rs+++ b/datafusion/common/src/datatype.rs@@ -81,7 +81,6 @@ pub trait FieldExt {/// assert_eq!(list_field.data_type(), &DataType::List(Arc::new(/// Field::new("item", DataType::Int32, true)/// )));- ///fn into_list(self) -> Self;/// Return a new Field representing this Field as the item type of a@@ -107,7 +106,6 @@ pub trait FieldExt {/// Field::new("item", DataType::Int32, true)),/// 3/// ));- ///fn into_fixed_size_list(self, list_size: i32) -> Self;/// Update the field to have the default list field name ("item")diff --git a/datafusion/common/src/dfschema.rs b/datafusion/common/src/dfschema.rsindex 34a36f5436..24d152a7db 100644--- a/datafusion/common/src/dfschema.rs+++ b/datafusion/common/src/dfschema.rs@@ -56,12 +56,10 @@ pub type DFSchemaRef = Arc<DFSchema>;/// an Arrow schema.////// ```rust-/// use datafusion_common::{DFSchema, Column};/// use arrow::datatypes::{DataType, Field, Schema};+/// use datafusion_common::{Column, DFSchema};///-/// let arrow_schema = Schema::new(vec![-/// Field::new("c1", DataType::Int32, false),-/// ]);+/// let arrow_schema = Schema::new(vec![Field::new("c1", DataType::Int32, false)]);////// let df_schema = DFSchema::try_from_qualified_schema("t1", &arrow_schema).unwrap();/// let column = Column::from_qualified_name("t1.c1");@@ -77,12 +75,10 @@ pub type DFSchemaRef = Arc<DFSchema>;/// Create an unqualified schema using TryFrom:////// ```rust-/// use datafusion_common::{DFSchema, Column};/// use arrow::datatypes::{DataType, Field, Schema};+/// use datafusion_common::{Column, DFSchema};///-/// let arrow_schema = Schema::new(vec![-/// Field::new("c1", DataType::Int32, false),-/// ]);+/// let arrow_schema = Schema::new(vec![Field::new("c1", DataType::Int32, false)]);////// let df_schema = DFSchema::try_from(arrow_schema).unwrap();/// let column = Column::new_unqualified("c1");@@ -94,13 +90,15 @@ pub type DFSchemaRef = Arc<DFSchema>;/// Use the `Into` trait to convert `DFSchema` into an Arrow schema:////// ```rust+/// use arrow::datatypes::{Field, Schema};/// use datafusion_common::DFSchema;-/// use arrow::datatypes::{Schema, Field};/// use std::collections::HashMap;///-/// let df_schema = DFSchema::from_unqualified_fields(vec![-/// Field::new("c1", arrow::datatypes::DataType::Int32, false),-/// ].into(),HashMap::new()).unwrap();+/// let df_schema = DFSchema::from_unqualified_fields(+/// vec![Field::new("c1", arrow::datatypes::DataType::Int32, false)].into(),+/// HashMap::new(),+/// )+/// .unwrap();/// let schema: &Schema = df_schema.as_arrow();/// assert_eq!(schema.fields().len(), 1);/// ```@@ -884,22 +882,26 @@ impl DFSchema {/// # Example////// ```- /// use datafusion_common::DFSchema;/// use arrow::datatypes::{DataType, Field, Schema};+ /// use datafusion_common::DFSchema;/// use std::collections::HashMap;////// let schema = DFSchema::from_unqualified_fields(/// vec![/// Field::new("id", DataType::Int32, false),/// Field::new("name", DataType::Utf8, true),- /// ].into(),- /// HashMap::new()- /// ).unwrap();+ /// ]+ /// .into(),+ /// HashMap::new(),+ /// )+ /// .unwrap();///- /// assert_eq!(schema.tree_string().to_string(),- /// r#"root+ /// assert_eq!(+ /// schema.tree_string().to_string(),+ /// r#"root/// |-- id: int32 (nullable = false)- /// |-- name: utf8 (nullable = true)"#);+ /// |-- name: utf8 (nullable = true)"#+ /// );/// ```pub fn tree_string(&self) -> impl Display + '_ {let mut result = String::from("root\n");diff --git a/datafusion/common/src/diagnostic.rs b/datafusion/common/src/diagnostic.rsindex 0dce8e6a56..b25bf1c12e 100644--- a/datafusion/common/src/diagnostic.rs+++ b/datafusion/common/src/diagnostic.rs@@ -30,8 +30,11 @@ use crate::Span;/// ```rust/// # use datafusion_common::{Location, Span, Diagnostic};/// let span = Some(Span {-/// start: Location{ line: 2, column: 1 },-/// end: Location{ line: 4, column: 15 }+/// start: Location { line: 2, column: 1 },+/// end: Location {+/// line: 4,+/// column: 15,+/// },/// });/// let diagnostic = Diagnostic::new_error("Something went wrong", span)/// .with_help("Have you tried turning it on and off again?", None);diff --git a/datafusion/common/src/error.rs b/datafusion/common/src/error.rsindex 210f044297..fde52944d0 100644--- a/datafusion/common/src/error.rs+++ b/datafusion/common/src/error.rs@@ -684,7 +684,10 @@ impl DataFusionError {/// let mut builder = DataFusionError::builder();/// builder.add_error(DataFusionError::Internal("foo".to_owned()));/// // ok_or returns the value if no errors have been added-/// assert_contains!(builder.error_or(42).unwrap_err().to_string(), "Internal error: foo");+/// assert_contains!(+/// builder.error_or(42).unwrap_err().to_string(),+/// "Internal error: foo"+/// );/// ```#[derive(Debug, Default)]pub struct DataFusionErrorBuilder(Vec<DataFusionError>);@@ -702,7 +705,10 @@ impl DataFusionErrorBuilder {/// # use datafusion_common::{assert_contains, DataFusionError};/// let mut builder = DataFusionError::builder();/// builder.add_error(DataFusionError::Internal("foo".to_owned()));- /// assert_contains!(builder.error_or(42).unwrap_err().to_string(), "Internal error: foo");+ /// assert_contains!(+ /// builder.error_or(42).unwrap_err().to_string(),+ /// "Internal error: foo"+ /// );/// ```pub fn add_error(&mut self, error: DataFusionError) {self.0.push(error);@@ -714,8 +720,11 @@ impl DataFusionErrorBuilder {/// ```/// # use datafusion_common::{assert_contains, DataFusionError};/// let builder = DataFusionError::builder()- /// .with_error(DataFusionError::Internal("foo".to_owned()));- /// assert_contains!(builder.error_or(42).unwrap_err().to_string(), "Internal error: foo");+ /// .with_error(DataFusionError::Internal("foo".to_owned()));+ /// assert_contains!(+ /// builder.error_or(42).unwrap_err().to_string(),+ /// "Internal error: foo"+ /// );/// ```pub fn with_error(mut self, error: DataFusionError) -> Self {self.0.push(error);diff --git a/datafusion/common/src/metadata.rs b/datafusion/common/src/metadata.rsindex 39065808ef..3a10cc2b42 100644--- a/datafusion/common/src/metadata.rs+++ b/datafusion/common/src/metadata.rs@@ -171,7 +171,6 @@ pub fn format_type_and_metadata(/// // Add any metadata from `FieldMetadata` to `Field`/// let updated_field = metadata.add_to_field(field);/// ```-///#[derive(Clone, PartialEq, Eq, PartialOrd, Hash, Debug)]pub struct FieldMetadata {/// The inner metadata of a literal expression, which is a map of stringdiff --git a/datafusion/common/src/nested_struct.rs b/datafusion/common/src/nested_struct.rsindex 38060e370b..d43816f75b 100644--- a/datafusion/common/src/nested_struct.rs+++ b/datafusion/common/src/nested_struct.rs@@ -110,16 +110,19 @@ fn cast_struct_column(/// temporal values are formatted when cast to strings.////// ```-/// use std::sync::Arc;-/// use arrow::array::{Int64Array, ArrayRef};+/// use arrow::array::{ArrayRef, Int64Array};/// use arrow::compute::CastOptions;/// use arrow::datatypes::{DataType, Field};/// use datafusion_common::nested_struct::cast_column;+/// use std::sync::Arc;////// let source: ArrayRef = Arc::new(Int64Array::from(vec![1, i64::MAX]));/// let target = Field::new("ints", DataType::Int32, true);/// // Permit lossy conversions by producing NULL on overflow instead of erroring-/// let options = CastOptions { safe: true, ..Default::default() };+/// let options = CastOptions {+/// safe: true,+/// ..Default::default()+/// };/// let result = cast_column(&source, &target, &options).unwrap();/// assert!(result.is_null(1));/// ```diff --git a/datafusion/common/src/scalar/mod.rs b/datafusion/common/src/scalar/mod.rsindex a70a027a8f..f2546040ff 100644--- a/datafusion/common/src/scalar/mod.rs+++ b/datafusion/common/src/scalar/mod.rs@@ -171,9 +171,9 @@ pub use struct_builder::ScalarStructBuilder;/// let field_b = Field::new("b", DataType::Utf8, false);////// let s1 = ScalarStructBuilder::new()-/// .with_scalar(field_a, ScalarValue::from(1i32))-/// .with_scalar(field_b, ScalarValue::from("foo"))-/// .build();+/// .with_scalar(field_a, ScalarValue::from(1i32))+/// .with_scalar(field_b, ScalarValue::from("foo"))+/// .build();/// ```////// ## Example: Creating a null [`ScalarValue::Struct`] using [`ScalarStructBuilder`]@@ -199,13 +199,13 @@ pub use struct_builder::ScalarStructBuilder;/// // Build a struct like: {a: 1, b: "foo"}/// // Field description/// let fields = Fields::from(vec![-/// Field::new("a", DataType::Int32, false),-/// Field::new("b", DataType::Utf8, false),+/// Field::new("a", DataType::Int32, false),+/// Field::new("b", DataType::Utf8, false),/// ]);/// // one row arrays for each field/// let arrays: Vec<ArrayRef> = vec![-/// Arc::new(Int32Array::from(vec![1])),-/// Arc::new(StringArray::from(vec!["foo"])),+/// Arc::new(Int32Array::from(vec![1])),+/// Arc::new(StringArray::from(vec!["foo"])),/// ];/// // no nulls for this array/// let nulls = None;@@ -1068,8 +1068,8 @@ impl ScalarValue {////// Example/// ```- /// use datafusion_common::ScalarValue;/// use arrow::datatypes::DataType;+ /// use datafusion_common::ScalarValue;////// let scalar = ScalarValue::try_new_null(&DataType::Int32).unwrap();/// assert_eq!(scalar.is_null(), true);@@ -2231,23 +2231,16 @@ impl ScalarValue {////// # Example/// ```- /// use datafusion_common::ScalarValue;/// use arrow::array::{BooleanArray, Int32Array};+ /// use datafusion_common::ScalarValue;////// let arr = Int32Array::from(vec![Some(1), None, Some(10)]);/// let five = ScalarValue::Int32(Some(5));///- /// let result = arrow::compute::kernels::cmp::lt(- /// &arr,- /// &five.to_scalar().unwrap(),- /// ).unwrap();+ /// let result =+ /// arrow::compute::kernels::cmp::lt(&arr, &five.to_scalar().unwrap()).unwrap();///- /// let expected = BooleanArray::from(vec![- /// Some(true),- /// None,- /// Some(false)- /// ]- /// );+ /// let expected = BooleanArray::from(vec![Some(true), None, Some(false)]);////// assert_eq!(&result, &expected);/// ```@@ -2265,26 +2258,20 @@ impl ScalarValue {////// # Example/// ```- /// use datafusion_common::ScalarValue;/// use arrow::array::{ArrayRef, BooleanArray};+ /// use datafusion_common::ScalarValue;////// let scalars = vec![- /// ScalarValue::Boolean(Some(true)),- /// ScalarValue::Boolean(None),- /// ScalarValue::Boolean(Some(false)),+ /// ScalarValue::Boolean(Some(true)),+ /// ScalarValue::Boolean(None),+ /// ScalarValue::Boolean(Some(false)),/// ];////// // Build an Array from the list of ScalarValues- /// let array = ScalarValue::iter_to_array(scalars.into_iter())- /// .unwrap();+ /// let array = ScalarValue::iter_to_array(scalars.into_iter()).unwrap();///- /// let expected: ArrayRef = std::sync::Arc::new(- /// BooleanArray::from(vec![- /// Some(true),- /// None,- /// Some(false)- /// ]- /// ));+ /// let expected: ArrayRef =+ /// std::sync::Arc::new(BooleanArray::from(vec![Some(true), None, Some(false)]));////// assert_eq!(&array, &expected);/// ```@@ -2731,23 +2718,24 @@ impl ScalarValue {////// Example/// ```- /// use datafusion_common::ScalarValue;- /// use arrow::array::{ListArray, Int32Array};+ /// use arrow::array::{Int32Array, ListArray};/// use arrow::datatypes::{DataType, Int32Type};/// use datafusion_common::cast::as_list_array;+ /// use datafusion_common::ScalarValue;////// let scalars = vec![- /// ScalarValue::Int32(Some(1)),- /// ScalarValue::Int32(None),- /// ScalarValue::Int32(Some(2))+ /// ScalarValue::Int32(Some(1)),+ /// ScalarValue::Int32(None),+ /// ScalarValue::Int32(Some(2)),/// ];////// let result = ScalarValue::new_list(&scalars, &DataType::Int32, true);///- /// let expected = ListArray::from_iter_primitive::<Int32Type, _, _>(- /// vec![- /// Some(vec![Some(1), None, Some(2)])- /// ]);+ /// let expected = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![Some(vec![+ /// Some(1),+ /// None,+ /// Some(2),+ /// ])]);////// assert_eq!(*result, expected);/// ```@@ -2791,23 +2779,25 @@ impl ScalarValue {////// Example/// ```- /// use datafusion_common::ScalarValue;- /// use arrow::array::{ListArray, Int32Array};+ /// use arrow::array::{Int32Array, ListArray};/// use arrow::datatypes::{DataType, Int32Type};/// use datafusion_common::cast::as_list_array;+ /// use datafusion_common::ScalarValue;////// let scalars = vec![- /// ScalarValue::Int32(Some(1)),- /// ScalarValue::Int32(None),- /// ScalarValue::Int32(Some(2))+ /// ScalarValue::Int32(Some(1)),+ /// ScalarValue::Int32(None),+ /// ScalarValue::Int32(Some(2)),/// ];///- /// let result = ScalarValue::new_list_from_iter(scalars.into_iter(), &DataType::Int32, true);+ /// let result =+ /// ScalarValue::new_list_from_iter(scalars.into_iter(), &DataType::Int32, true);///- /// let expected = ListArray::from_iter_primitive::<Int32Type, _, _>(- /// vec![- /// Some(vec![Some(1), None, Some(2)])- /// ]);+ /// let expected = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![Some(vec![+ /// Some(1),+ /// None,+ /// Some(2),+ /// ])]);////// assert_eq!(*result, expected);/// ```@@ -2833,23 +2823,25 @@ impl ScalarValue {////// Example/// ```- /// use datafusion_common::ScalarValue;- /// use arrow::array::{LargeListArray, Int32Array};+ /// use arrow::array::{Int32Array, LargeListArray};/// use arrow::datatypes::{DataType, Int32Type};/// use datafusion_common::cast::as_large_list_array;+ /// use datafusion_common::ScalarValue;////// let scalars = vec![- /// ScalarValue::Int32(Some(1)),- /// ScalarValue::Int32(None),- /// ScalarValue::Int32(Some(2))+ /// ScalarValue::Int32(Some(1)),+ /// ScalarValue::Int32(None),+ /// ScalarValue::Int32(Some(2)),/// ];////// let result = ScalarValue::new_large_list(&scalars, &DataType::Int32);///- /// let expected = LargeListArray::from_iter_primitive::<Int32Type, _, _>(- /// vec![- /// Some(vec![Some(1), None, Some(2)])- /// ]);+ /// let expected =+ /// LargeListArray::from_iter_primitive::<Int32Type, _, _>(vec![Some(vec![+ /// Some(1),+ /// None,+ /// Some(2),+ /// ])]);////// assert_eq!(*result, expected);/// ```@@ -3248,14 +3240,14 @@ impl ScalarValue {////// Example 1: Array (ScalarValue::Int32)/// ```- /// use datafusion_common::ScalarValue;/// use arrow::array::ListArray;/// use arrow::datatypes::{DataType, Int32Type};+ /// use datafusion_common::ScalarValue;////// // Equivalent to [[1,2,3], [4,5]]/// let list_arr = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![- /// Some(vec![Some(1), Some(2), Some(3)]),- /// Some(vec![Some(4), Some(5)])+ /// Some(vec![Some(1), Some(2), Some(3)]),+ /// Some(vec![Some(4), Some(5)]),/// ]);////// // Convert the array into Scalar Values for each row@@ -3278,15 +3270,15 @@ impl ScalarValue {////// Example 2: Nested array (ScalarValue::List)/// ```- /// use datafusion_common::ScalarValue;/// use arrow::array::ListArray;/// use arrow::datatypes::{DataType, Int32Type};/// use datafusion_common::utils::SingleRowListArrayBuilder;+ /// use datafusion_common::ScalarValue;/// use std::sync::Arc;////// let list_arr = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![- /// Some(vec![Some(1), Some(2), Some(3)]),- /// Some(vec![Some(4), Some(5)])+ /// Some(vec![Some(1), Some(2), Some(3)]),+ /// Some(vec![Some(4), Some(5)]),/// ]);////// // Wrap into another layer of list, we got nested array as [ [[1,2,3], [4,5]] ]@@ -3295,33 +3287,34 @@ impl ScalarValue {/// // Convert the array into Scalar Values for each row, we got 1D arrays in this example/// let scalar_vec = ScalarValue::convert_array_to_scalar_vec(&list_arr).unwrap();///- /// let l1 = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![- /// Some(vec![Some(1), Some(2), Some(3)]),- /// ]);- /// let l2 = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![- /// Some(vec![Some(4), Some(5)]),- /// ]);+ /// let l1 = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![Some(vec![+ /// Some(1),+ /// Some(2),+ /// Some(3),+ /// ])]);+ /// let l2 = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![Some(vec![+ /// Some(4),+ /// Some(5),+ /// ])]);///- /// let expected = vec![- /// Some(vec![+ /// let expected = vec![Some(vec![/// ScalarValue::List(Arc::new(l1)),/// ScalarValue::List(Arc::new(l2)),- /// ]),- /// ];+ /// ])];////// assert_eq!(scalar_vec, expected);/// ```////// Example 3: Nullable array/// ```- /// use datafusion_common::ScalarValue;/// use arrow::array::ListArray;/// use arrow::datatypes::{DataType, Int32Type};+ /// use datafusion_common::ScalarValue;////// let list_arr = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![- /// Some(vec![Some(1), Some(2), Some(3)]),- /// None,- /// Some(vec![Some(4), Some(5)])+ /// Some(vec![Some(1), Some(2), Some(3)]),+ /// None,+ /// Some(vec![Some(4), Some(5)]),/// ]);////// // Convert the array into Scalar Values for each rowdiff --git a/datafusion/common/src/scalar/struct_builder.rs b/datafusion/common/src/scalar/struct_builder.rsindex fd19dccf89..56daee9045 100644--- a/datafusion/common/src/scalar/struct_builder.rs+++ b/datafusion/common/src/scalar/struct_builder.rs@@ -47,13 +47,11 @@ impl ScalarStructBuilder {/// ```rust/// # use arrow::datatypes::{DataType, Field};/// # use datafusion_common::scalar::ScalarStructBuilder;- /// let fields = vec![- /// Field::new("a", DataType::Int32, false),- /// ];+ /// let fields = vec![Field::new("a", DataType::Int32, false)];/// let sv = ScalarStructBuilder::new_null(fields);/// // Note this is `NULL`, not `{a: NULL}`/// assert_eq!(format!("{sv}"), "NULL");- ///```+ /// ```////// To create a struct where the *fields* are null, use `Self::new()` and/// pass null values for each field:@@ -65,9 +63,9 @@ impl ScalarStructBuilder {/// let field = Field::new("a", DataType::Int32, true);/// // add a null value for the "a" field/// let sv = ScalarStructBuilder::new()- /// .with_scalar(field, ScalarValue::Int32(None))- /// .build()- /// .unwrap();+ /// .with_scalar(field, ScalarValue::Int32(None))+ /// .build()+ /// .unwrap();/// // value is not null, but field is/// assert_eq!(format!("{sv}"), "{a:}");/// ```diff --git a/datafusion/common/src/stats.rs b/datafusion/common/src/stats.rsindex 2481a88676..da298c20eb 100644--- a/datafusion/common/src/stats.rs+++ b/datafusion/common/src/stats.rs@@ -520,33 +520,35 @@ impl Statistics {/// # use arrow::datatypes::{Field, Schema, DataType};/// # use datafusion_common::stats::Precision;/// let stats1 = Statistics::default()- /// .with_num_rows(Precision::Exact(1))- /// .with_total_byte_size(Precision::Exact(2))- /// .add_column_statistics(ColumnStatistics::new_unknown()- /// .with_null_count(Precision::Exact(3))- /// .with_min_value(Precision::Exact(ScalarValue::from(4)))- /// .with_max_value(Precision::Exact(ScalarValue::from(5)))- /// );+ /// .with_num_rows(Precision::Exact(1))+ /// .with_total_byte_size(Precision::Exact(2))+ /// .add_column_statistics(+ /// ColumnStatistics::new_unknown()+ /// .with_null_count(Precision::Exact(3))+ /// .with_min_value(Precision::Exact(ScalarValue::from(4)))+ /// .with_max_value(Precision::Exact(ScalarValue::from(5))),+ /// );////// let stats2 = Statistics::default()- /// .with_num_rows(Precision::Exact(10))- /// .with_total_byte_size(Precision::Inexact(20))- /// .add_column_statistics(ColumnStatistics::new_unknown()- /// // absent null count- /// .with_min_value(Precision::Exact(ScalarValue::from(40)))- /// .with_max_value(Precision::Exact(ScalarValue::from(50)))- /// );+ /// .with_num_rows(Precision::Exact(10))+ /// .with_total_byte_size(Precision::Inexact(20))+ /// .add_column_statistics(+ /// ColumnStatistics::new_unknown()+ /// // absent null count+ /// .with_min_value(Precision::Exact(ScalarValue::from(40)))+ /// .with_max_value(Precision::Exact(ScalarValue::from(50))),+ /// );////// let merged_stats = stats1.try_merge(&stats2).unwrap();/// let expected_stats = Statistics::default()- /// .with_num_rows(Precision::Exact(11))- /// .with_total_byte_size(Precision::Inexact(22)) // inexact in stats2 --> inexact- /// .add_column_statistics(- /// ColumnStatistics::new_unknown()- /// .with_null_count(Precision::Absent) // missing from stats2 --> absent- /// .with_min_value(Precision::Exact(ScalarValue::from(4)))- /// .with_max_value(Precision::Exact(ScalarValue::from(50)))- /// );+ /// .with_num_rows(Precision::Exact(11))+ /// .with_total_byte_size(Precision::Inexact(22)) // inexact in stats2 --> inexact+ /// .add_column_statistics(+ /// ColumnStatistics::new_unknown()+ /// .with_null_count(Precision::Absent) // missing from stats2 --> absent+ /// .with_min_value(Precision::Exact(ScalarValue::from(4)))+ /// .with_max_value(Precision::Exact(ScalarValue::from(50))),+ /// );////// assert_eq!(merged_stats, expected_stats)/// ```diff --git a/datafusion/common/src/table_reference.rs b/datafusion/common/src/table_reference.rsindex 5744658567..3163a8b16c 100644--- a/datafusion/common/src/table_reference.rs+++ b/datafusion/common/src/table_reference.rs@@ -69,8 +69,11 @@ impl std::fmt::Display for ResolvedTableReference {////// // Get a table reference to 'myschema.mytable' (note the capitalization)/// let table_reference = TableReference::from("MySchema.MyTable");-/// assert_eq!(table_reference, TableReference::partial("myschema", "mytable"));-///```+/// assert_eq!(+/// table_reference,+/// TableReference::partial("myschema", "mytable")+/// );+/// ```#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]pub enum TableReference {/// An unqualified table reference, e.g. "table"@@ -247,7 +250,10 @@ impl TableReference {/// assert_eq!(table_reference.to_quoted_string(), "myschema.mytable");////// let table_reference = TableReference::partial("MySchema", "MyTable");- /// assert_eq!(table_reference.to_quoted_string(), r#""MySchema"."MyTable""#);+ /// assert_eq!(+ /// table_reference.to_quoted_string(),+ /// r#""MySchema"."MyTable""#+ /// );/// ```pub fn to_quoted_string(&self) -> String {match self {diff --git a/datafusion/common/src/test_util.rs b/datafusion/common/src/test_util.rsindex d97d4003e7..c51dea1c4d 100644--- a/datafusion/common/src/test_util.rs+++ b/datafusion/common/src/test_util.rs@@ -55,7 +55,7 @@ pub fn format_batches(results: &[RecordBatch]) -> Result<impl Display, ArrowErro/// # use arrow::array::{ArrayRef, Int32Array};/// # use datafusion_common::assert_batches_eq;/// let col: ArrayRef = Arc::new(Int32Array::from(vec![1, 2]));-/// let batch = RecordBatch::try_from_iter([("column", col)]).unwrap();+/// let batch = RecordBatch::try_from_iter([("column", col)]).unwrap();/// // Expected output is a vec of strings/// let expected = vec![/// "+--------+",diff --git a/datafusion/common/src/tree_node.rs b/datafusion/common/src/tree_node.rsindex ea0aa28c93..9b36266eec 100644--- a/datafusion/common/src/tree_node.rs+++ b/datafusion/common/src/tree_node.rs@@ -638,12 +638,13 @@ impl TreeNodeRecursion {/// # fn make_new_expr(i: i64) -> i64 { 2 }/// let expr = orig_expr();/// let ret = Transformed::no(expr.clone())-/// .transform_data(|expr| {-/// // closure returns a result and potentially transforms the node-/// // in this example, it does transform the node-/// let new_expr = make_new_expr(expr);-/// Ok(Transformed::yes(new_expr))-/// }).unwrap();+/// .transform_data(|expr| {+/// // closure returns a result and potentially transforms the node+/// // in this example, it does transform the node+/// let new_expr = make_new_expr(expr);+/// Ok(Transformed::yes(new_expr))+/// })+/// .unwrap();/// // transformed flag is the union of the original ans closure's transformed flag/// assert!(ret.transformed);/// ```diff --git a/datafusion/common/src/types/logical.rs b/datafusion/common/src/types/logical.rsindex eb7cf88e00..674b1a4120 100644--- a/datafusion/common/src/types/logical.rs+++ b/datafusion/common/src/types/logical.rs@@ -67,12 +67,12 @@ pub type LogicalTypeRef = Arc<dyn LogicalType>;/// &NativeType::String/// }///-/// fn signature(&self) -> TypeSignature<'_> {-/// TypeSignature::Extension {-/// name: "JSON",-/// parameters: &[],-/// }-/// }+/// fn signature(&self) -> TypeSignature<'_> {+/// TypeSignature::Extension {+/// name: "JSON",+/// parameters: &[],+/// }+/// }/// }/// ```pub trait LogicalType: Sync + Send {diff --git a/datafusion/common/src/utils/memory.rs b/datafusion/common/src/utils/memory.rsindex 29e523996c..a56b940fab 100644--- a/datafusion/common/src/utils/memory.rs+++ b/datafusion/common/src/utils/memory.rs@@ -56,8 +56,8 @@ use std::mem::size_of;/// impl<T> MyStruct<T> {/// fn size(&self) -> Result<usize> {/// let num_elements = self.values.len();-/// let fixed_size = std::mem::size_of_val(self) +-/// std::mem::size_of_val(&self.values);+/// let fixed_size =+/// std::mem::size_of_val(self) + std::mem::size_of_val(&self.values);////// estimate_memory_size::<T>(num_elements, fixed_size)/// }@@ -73,8 +73,8 @@ use std::mem::size_of;/// let num_rows = 100;/// let fixed_size = std::mem::size_of::<HashMap<u64, u64>>();/// let estimated_hashtable_size =-/// estimate_memory_size::<(u64, u64)>(num_rows,fixed_size)-/// .expect("Size estimation failed");+/// estimate_memory_size::<(u64, u64)>(num_rows, fixed_size)+/// .expect("Size estimation failed");/// ```pub fn estimate_memory_size<T>(num_elements: usize, fixed_size: usize) -> Result<usize> {// For the majority of cases hashbrown overestimates the bucket quantitydiff --git a/datafusion/common/src/utils/mod.rs b/datafusion/common/src/utils/mod.rsindex 045c02a5a2..7b145ac3ae 100644--- a/datafusion/common/src/utils/mod.rs+++ b/datafusion/common/src/utils/mod.rs@@ -46,26 +46,23 @@ use std::thread::available_parallelism;////// Example:/// ```-/// use arrow::datatypes::{SchemaRef, Schema, Field, DataType};+/// use arrow::datatypes::{DataType, Field, Schema, SchemaRef};/// use datafusion_common::project_schema;////// // Schema with columns 'a', 'b', and 'c'/// let schema = SchemaRef::new(Schema::new(vec![-/// Field::new("a", DataType::Int32, true),-/// Field::new("b", DataType::Int64, true),-/// Field::new("c", DataType::Utf8, true),+/// Field::new("a", DataType::Int32, true),+/// Field::new("b", DataType::Int64, true),+/// Field::new("c", DataType::Utf8, true),/// ]));////// // Pick columns 'c' and 'b'-/// let projection = Some(vec![2,1]);-/// let projected_schema = project_schema(-/// &schema,-/// projection.as_ref()-/// ).unwrap();+/// let projection = Some(vec![2, 1]);+/// let projected_schema = project_schema(&schema, projection.as_ref()).unwrap();////// let expected_schema = SchemaRef::new(Schema::new(vec![-/// Field::new("c", DataType::Utf8, true),-/// Field::new("b", DataType::Int64, true),+/// Field::new("c", DataType::Utf8, true),+/// Field::new("b", DataType::Int64, true),/// ]));////// assert_eq!(projected_schema, expected_schema);@@ -398,9 +395,11 @@ pub fn longest_consecutive_prefix<T: Borrow<usize>>(/// # use arrow::array::types::Int64Type;/// # use datafusion_common::utils::SingleRowListArrayBuilder;/// // Array is [1, 2, 3]-/// let arr = ListArray::from_iter_primitive::<Int64Type, _, _>(vec![-/// Some(vec![Some(1), Some(2), Some(3)]),-/// ]);+/// let arr = ListArray::from_iter_primitive::<Int64Type, _, _>(vec![Some(vec![+/// Some(1),+/// Some(2),+/// Some(3),+/// ])]);/// // Wrap as a list array: [[1, 2, 3]]/// let list_arr = SingleRowListArrayBuilder::new(Arc::new(arr)).build_list_array();/// assert_eq!(list_arr.len(), 1);@@ -554,7 +553,8 @@ pub fn fixed_size_list_to_arrays(a: &ArrayRef) -> Vec<ArrayRef> {/// use datafusion_common::utils::base_type;/// use std::sync::Arc;///-/// let data_type = DataType::List(Arc::new(Field::new_list_field(DataType::Int32, true)));+/// let data_type =+/// DataType::List(Arc::new(Field::new_list_field(DataType::Int32, true)));/// assert_eq!(base_type(&data_type), DataType::Int32);////// let data_type = DataType::Int32;@@ -906,16 +906,19 @@ pub fn get_available_parallelism() -> usize {/// # use datafusion_common::utils::take_function_args;/// # use datafusion_common::ScalarValue;/// fn my_function(args: &[ScalarValue]) -> Result<()> {-/// // function expects 2 args, so create a 2-element array-/// let [arg1, arg2] = take_function_args("my_function", args)?;-/// // ... do stuff..-/// Ok(())+/// // function expects 2 args, so create a 2-element array+/// let [arg1, arg2] = take_function_args("my_function", args)?;+/// // ... do stuff..+/// Ok(())/// }////// // Calling the function with 1 argument produces an error:/// let args = vec![ScalarValue::Int32(Some(10))];/// let err = my_function(&args).unwrap_err();-/// assert_eq!(err.to_string(), "Execution error: my_function function requires 2 arguments, got 1");+/// assert_eq!(+/// err.to_string(),+/// "Execution error: my_function function requires 2 arguments, got 1"+/// );/// // Calling the function with 2 arguments works great/// let args = vec![ScalarValue::Int32(Some(10)), ScalarValue::Int32(Some(20))];/// my_function(&args).unwrap();diff --git a/datafusion/common/src/utils/proxy.rs b/datafusion/common/src/utils/proxy.rsindex d940677a5f..fb951aa3b0 100644--- a/datafusion/common/src/utils/proxy.rs+++ b/datafusion/common/src/utils/proxy.rs@@ -47,7 +47,9 @@ pub trait VecAllocExt {/// assert_eq!(allocated, 16); // no new allocation needed////// // push more data into the vec- /// for _ in 0..10 { vec.push_accounted(1, &mut allocated); }+ /// for _ in 0..10 {+ /// vec.push_accounted(1, &mut allocated);+ /// }/// assert_eq!(allocated, 64); // underlying vec has space for 10 u32s/// assert_eq!(vec.allocated_size(), 64);/// ```@@ -82,7 +84,9 @@ pub trait VecAllocExt {/// assert_eq!(vec.allocated_size(), 16); // no new allocation needed////// // push more data into the vec- /// for _ in 0..10 { vec.push(1); }+ /// for _ in 0..10 {+ /// vec.push(1);+ /// }/// assert_eq!(vec.allocated_size(), 64); // space for 64 now/// ```fn allocated_size(&self) -> usize;@@ -133,7 +137,9 @@ pub trait RawTableAllocExt {/// assert_eq!(allocated, 64);////// // insert more values- /// for i in 0..100 { table.insert_accounted(i, hash_fn, &mut allocated); }+ /// for i in 0..100 {+ /// table.insert_accounted(i, hash_fn, &mut allocated);+ /// }/// assert_eq!(allocated, 400);/// ```fn insert_accounted(@@ -200,7 +206,9 @@ pub trait HashTableAllocExt {/// assert_eq!(allocated, 64);////// // insert more values- /// for i in 0..100 { table.insert_accounted(i, hash_fn, &mut allocated); }+ /// for i in 0..100 {+ /// table.insert_accounted(i, hash_fn, &mut allocated);+ /// }/// assert_eq!(allocated, 400);/// ```fn insert_accounted(