Skip to content

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 string
diff --git a/datafusion/common/src/nested_struct.rs b/datafusion/common/src/nested_struct.rs
index 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.rs
index 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 row
diff --git a/datafusion/common/src/scalar/struct_builder.rs b/datafusion/common/src/scalar/struct_builder.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 quantity
diff --git a/datafusion/common/src/utils/mod.rs b/datafusion/common/src/utils/mod.rs
index 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.rs
index 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(