Apply nightly rustfmt formatting to doc comment code examples

CuteChuanChuan · CuteChuanChuan · commit 2c1d0d6efb51 · 2025-12-10T22:05:36.000+08:00
diff --git a/datafusion-examples/examples/data_io/remote_catalog.rs b/datafusion-examples/examples/data_io/remote_catalog.rs
@@ -16,7 +16,6 @@
 // under the License.
 
 //! See `main.rs` for how to run it.
-//!
 /// This example shows how to implement the DataFusion [`CatalogProvider`] API
 /// for catalogs that are remote (require network access) and/or offer only
 /// asynchronous APIs such as [Polaris], [Unity], and [Hive].
diff --git a/datafusion-examples/examples/udf/simple_udaf.rs b/datafusion-examples/examples/udf/simple_udaf.rs
@@ -16,7 +16,6 @@
 // under the License.
 
 //! See `main.rs` for how to run it.
-//!
 /// In this example we will declare a single-type, single return type UDAF that computes the geometric mean.
 /// The geometric mean is described here: https://en.wikipedia.org/wiki/Geometric_mean
 use datafusion::arrow::{
diff --git a/datafusion/common/src/scalar/mod.rs b/datafusion/common/src/scalar/mod.rs
@@ -2790,8 +2790,8 @@ impl ScalarValue {
     /// ```
     /// use arrow::array::{Int32Array, ListArray};
     /// use arrow::datatypes::{DataType, Int32Type};
-    /// use datafusion_common::cast::as_list_array;
     /// use datafusion_common::ScalarValue;
+    /// use datafusion_common::cast::as_list_array;
     ///
     /// let scalars = vec![
     ///     ScalarValue::Int32(Some(1)),
@@ -2851,8 +2851,8 @@ impl ScalarValue {
     /// ```
     /// use arrow::array::{Int32Array, ListArray};
     /// use arrow::datatypes::{DataType, Int32Type};
-    /// use datafusion_common::cast::as_list_array;
     /// use datafusion_common::ScalarValue;
+    /// use datafusion_common::cast::as_list_array;
     ///
     /// let scalars = vec![
     ///     ScalarValue::Int32(Some(1)),
@@ -2895,8 +2895,8 @@ impl ScalarValue {
     /// ```
     /// use arrow::array::{Int32Array, LargeListArray};
     /// use arrow::datatypes::{DataType, Int32Type};
-    /// use datafusion_common::cast::as_large_list_array;
     /// use datafusion_common::ScalarValue;
+    /// use datafusion_common::cast::as_large_list_array;
     ///
     /// let scalars = vec![
     ///     ScalarValue::Int32(Some(1)),
@@ -3345,8 +3345,8 @@ impl ScalarValue {
     /// ```
     /// use arrow::array::ListArray;
     /// use arrow::datatypes::{DataType, Int32Type};
-    /// use datafusion_common::utils::SingleRowListArrayBuilder;
     /// use datafusion_common::ScalarValue;
+    /// use datafusion_common::utils::SingleRowListArrayBuilder;
     /// use std::sync::Arc;
     ///
     /// let list_arr = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
diff --git a/datafusion/core/src/lib.rs b/datafusion/core/src/lib.rs
@@ -488,7 +488,7 @@
 //! consumes it immediately as well.
 //!
 //! ```text
-//!
+//! 
 //! Step 3: FilterExec calls next()       Step 2: ProjectionExec calls
 //!         on input Stream                  next() on input Stream
 //!         ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─      ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
diff --git a/datafusion/doc/src/lib.rs b/datafusion/doc/src/lib.rs
@@ -195,7 +195,7 @@ impl Default for DocSection {
 /// Example:
 ///
 /// ```rust
-///
+/// 
 /// # fn main() {
 ///     use datafusion_doc::{DocSection, Documentation};
 ///     let doc_section = DocSection {
diff --git a/datafusion/expr-common/src/interval_arithmetic.rs b/datafusion/expr-common/src/interval_arithmetic.rs
@@ -1317,7 +1317,7 @@ fn min_of_bounds(first: &ScalarValue, second: &ScalarValue) -> ScalarValue {
 /// Example usage:
 /// ```
 /// use datafusion_common::DataFusionError;
-/// use datafusion_expr_common::interval_arithmetic::{satisfy_greater, Interval};
+/// use datafusion_expr_common::interval_arithmetic::{Interval, satisfy_greater};
 ///
 /// let left = Interval::make(Some(-1000.0_f32), Some(1000.0_f32))?;
 /// let right = Interval::make(Some(500.0_f32), Some(2000.0_f32))?;
diff --git a/datafusion/expr-common/src/signature.rs b/datafusion/expr-common/src/signature.rs
@@ -899,7 +899,7 @@ fn get_data_types(native_type: &NativeType) -> Vec<DataType> {
 /// # Examples
 ///
 /// ```
-/// use datafusion_common::types::{logical_binary, logical_string, NativeType};
+/// use datafusion_common::types::{NativeType, logical_binary, logical_string};
 /// use datafusion_expr_common::signature::{Coercion, TypeSignatureClass};
 ///
 /// // Exact coercion that only accepts timestamp types
diff --git a/datafusion/expr/src/expr.rs b/datafusion/expr/src/expr.rs
@@ -1851,7 +1851,7 @@ impl Expr {
     /// Example
     /// ```
     /// # use datafusion_common::Column;
-    /// use datafusion_expr::{col, Expr};
+    /// use datafusion_expr::{Expr, col};
     /// let expr = col("foo");
     /// assert_eq!(expr.try_as_col(), Some(&Column::from("foo")));
     ///
diff --git a/datafusion/expr/src/logical_plan/ddl.rs b/datafusion/expr/src/logical_plan/ddl.rs
@@ -255,8 +255,9 @@ impl CreateExternalTable {
     ///     TableReference::bare("my_table"),
     ///     "/path/to/data",
     ///     "parquet",
-    ///     Arc::new(DFSchema::empty())
-    /// ).build();
+    ///     Arc::new(DFSchema::empty()),
+    /// )
+    /// .build();
     /// ```
     pub fn builder(
         name: impl Into<TableReference>,
diff --git a/datafusion/expr/src/logical_plan/plan.rs b/datafusion/expr/src/logical_plan/plan.rs
@@ -1587,7 +1587,7 @@ impl LogicalPlan {
     ///
     /// ```
     /// use arrow::datatypes::{DataType, Field, Schema};
-    /// use datafusion_expr::{col, lit, logical_plan::table_scan, LogicalPlanBuilder};
+    /// use datafusion_expr::{LogicalPlanBuilder, col, lit, logical_plan::table_scan};
     /// let schema = Schema::new(vec![Field::new("id", DataType::Int32, false)]);
     /// let plan = table_scan(Some("t1"), &schema, None)
     ///     .unwrap()
@@ -1629,7 +1629,7 @@ impl LogicalPlan {
     ///
     /// ```
     /// use arrow::datatypes::{DataType, Field, Schema};
-    /// use datafusion_expr::{col, lit, logical_plan::table_scan, LogicalPlanBuilder};
+    /// use datafusion_expr::{LogicalPlanBuilder, col, lit, logical_plan::table_scan};
     /// let schema = Schema::new(vec![Field::new("id", DataType::Int32, false)]);
     /// let plan = table_scan(Some("t1"), &schema, None)
     ///     .unwrap()
@@ -1694,7 +1694,7 @@ impl LogicalPlan {
     ///
     /// ```
     /// use arrow::datatypes::{DataType, Field, Schema};
-    /// use datafusion_expr::{col, lit, logical_plan::table_scan, LogicalPlanBuilder};
+    /// use datafusion_expr::{LogicalPlanBuilder, col, lit, logical_plan::table_scan};
     /// let schema = Schema::new(vec![Field::new("id", DataType::Int32, false)]);
     /// let plan = table_scan(Some("t1"), &schema, None)
     ///     .unwrap()
@@ -1752,7 +1752,7 @@ impl LogicalPlan {
     /// ```
     /// ```
     /// use arrow::datatypes::{DataType, Field, Schema};
-    /// use datafusion_expr::{col, lit, logical_plan::table_scan, LogicalPlanBuilder};
+    /// use datafusion_expr::{LogicalPlanBuilder, col, lit, logical_plan::table_scan};
     /// let schema = Schema::new(vec![Field::new("id", DataType::Int32, false)]);
     /// let plan = table_scan(Some("t1"), &schema, None)
     ///     .unwrap()
diff --git a/datafusion/expr/src/predicate_bounds.rs b/datafusion/expr/src/predicate_bounds.rs
@@ -45,7 +45,6 @@ use datafusion_expr_common::operator::Operator;
 ///
 /// The function returns a [NullableInterval] that describes the possible boolean values the
 /// predicate can evaluate to.
-///
 pub(super) fn evaluate_bounds(
     predicate: &Expr,
     certainly_null_expr: Option<&Expr>,
diff --git a/datafusion/expr/src/udf.rs b/datafusion/expr/src/udf.rs
@@ -142,7 +142,7 @@ impl ScalarUDF {
     ///
     /// # Example
     /// ```no_run
-    /// use datafusion_expr::{col, lit, ScalarUDF};
+    /// use datafusion_expr::{ScalarUDF, col, lit};
     /// # fn my_udf() -> ScalarUDF { unimplemented!() }
     /// let my_func: ScalarUDF = my_udf();
     /// // Create an expr for `my_func(a, 12.3)`
diff --git a/datafusion/functions-aggregate-common/src/tdigest.rs b/datafusion/functions-aggregate-common/src/tdigest.rs
@@ -523,7 +523,7 @@ impl TDigest {
     /// [`ScalarValue::Float64`]:
     ///
     /// ```text
-    ///
+    /// 
     ///    ┌────────┬────────┬────────┬───────┬────────┬────────┐
     ///    │max_size│  sum   │ count  │  max  │  min   │centroid│
     ///    └────────┴────────┴────────┴───────┴────────┴────────┘
diff --git a/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs b/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs
@@ -148,7 +148,7 @@ impl<S: SimplifyInfo> ExprSimplifier<S> {
     /// use datafusion_expr::execution_props::ExecutionProps;
     /// use datafusion_expr::simplify::SimplifyContext;
     /// use datafusion_expr::simplify::SimplifyInfo;
-    /// use datafusion_expr::{col, lit, Expr};
+    /// use datafusion_expr::{Expr, col, lit};
     /// use datafusion_optimizer::simplify_expressions::ExprSimplifier;
     /// use std::sync::Arc;
     ///
@@ -290,7 +290,7 @@ impl<S: SimplifyInfo> ExprSimplifier<S> {
     /// use datafusion_expr::execution_props::ExecutionProps;
     /// use datafusion_expr::interval_arithmetic::{Interval, NullableInterval};
     /// use datafusion_expr::simplify::SimplifyContext;
-    /// use datafusion_expr::{col, lit, Expr};
+    /// use datafusion_expr::{Expr, col, lit};
     /// use datafusion_optimizer::simplify_expressions::ExprSimplifier;
     ///
     /// let schema = Schema::new(vec![
@@ -352,7 +352,7 @@ impl<S: SimplifyInfo> ExprSimplifier<S> {
     /// use datafusion_expr::execution_props::ExecutionProps;
     /// use datafusion_expr::interval_arithmetic::{Interval, NullableInterval};
     /// use datafusion_expr::simplify::SimplifyContext;
-    /// use datafusion_expr::{col, lit, Expr};
+    /// use datafusion_expr::{Expr, col, lit};
     /// use datafusion_optimizer::simplify_expressions::ExprSimplifier;
     ///
     /// let schema = Schema::new(vec![
diff --git a/datafusion/physical-expr/src/expressions/case/literal_lookup_table/mod.rs b/datafusion/physical-expr/src/expressions/case/literal_lookup_table/mod.rs
@@ -63,7 +63,6 @@ use std::fmt::Debug;
 ///     ELSE <optional-fallback_literal>
 /// END
 /// ```
-///
 #[derive(Debug)]
 pub(in super::super) struct LiteralLookupTable {
     /// The lookup table to use for evaluating the CASE expression
@@ -252,7 +251,6 @@ pub(super) trait WhenLiteralIndexMap: Debug + Send + Sync {
     ///
     /// the returned vector will be:
     /// - `[0, 2, else_index, 1, 0]`
-    ///
     fn map_to_when_indices(
         &self,
         array: &ArrayRef,
diff --git a/datafusion/physical-expr/src/intervals/cp_solver.rs b/datafusion/physical-expr/src/intervals/cp_solver.rs
@@ -562,11 +562,11 @@ impl ExprIntervalGraph {
     /// use arrow::datatypes::Field;
     /// use arrow::datatypes::Schema;
     /// use datafusion_common::ScalarValue;
-    /// use datafusion_expr::interval_arithmetic::Interval;
     /// use datafusion_expr::Operator;
+    /// use datafusion_expr::interval_arithmetic::Interval;
+    /// use datafusion_physical_expr::PhysicalExpr;
     /// use datafusion_physical_expr::expressions::{BinaryExpr, Column, Literal};
     /// use datafusion_physical_expr::intervals::cp_solver::ExprIntervalGraph;
-    /// use datafusion_physical_expr::PhysicalExpr;
     /// use std::sync::Arc;
     ///
     /// let expr = Arc::new(BinaryExpr::new(
diff --git a/datafusion/physical-expr/src/projection.rs b/datafusion/physical-expr/src/projection.rs
@@ -249,12 +249,12 @@ impl ProjectionExprs {
     /// # Example
     ///
     /// ```rust
-    /// use std::sync::Arc;
     /// use arrow::datatypes::{DataType, Field, Schema};
     /// use datafusion_common::Result;
+    /// use datafusion_physical_expr::PhysicalExpr;
     /// use datafusion_physical_expr::expressions::Column;
     /// use datafusion_physical_expr::projection::ProjectionExprs;
-    /// use datafusion_physical_expr::PhysicalExpr;
+    /// use std::sync::Arc;
     ///
     /// // Create a schema and projection
     /// let schema = Arc::new(Schema::new(vec![
@@ -484,10 +484,10 @@ impl ProjectionExprs {
     ///
     /// ```rust
     /// use arrow::datatypes::{DataType, Field, Schema};
-    /// use datafusion_common::stats::{ColumnStatistics, Precision, Statistics};
-    /// use datafusion_physical_expr::projection::ProjectionExprs;
     /// use datafusion_common::Result;
     /// use datafusion_common::ScalarValue;
+    /// use datafusion_common::stats::{ColumnStatistics, Precision, Statistics};
+    /// use datafusion_physical_expr::projection::ProjectionExprs;
     /// use std::sync::Arc;
     ///
     /// fn main() -> Result<()> {
diff --git a/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/mod.rs b/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/mod.rs
@@ -180,7 +180,6 @@ pub struct GroupValuesColumn<const STREAMING: bool> {
     /// We don't really store the actual `group values` in `hashtable`,
     /// instead we store the `group indices` pointing to values in `GroupValues`.
     /// And we use [`GroupIndexView`] to represent such `group indices` in table.
-    ///
     map: HashTable<(u64, GroupIndexView)>,
 
     /// The size of `map` in bytes
diff --git a/datafusion/physical-plan/src/aggregates/row_hash.rs b/datafusion/physical-plan/src/aggregates/row_hash.rs
@@ -224,7 +224,7 @@ impl SkipAggregationProbe {
 /// # Architecture
 ///
 /// ```text
-///
+/// 
 ///     Assigns a consecutive group           internally stores aggregate values
 ///     index for each unique set                     for all groups
 ///         of group values
diff --git a/datafusion/physical-plan/src/joins/hash_join/exec.rs b/datafusion/physical-plan/src/joins/hash_join/exec.rs
@@ -209,7 +209,7 @@ impl JoinLeftData {
 ///
 ///
 /// ```text
-///
+/// 
 ///  Original build-side data   Inserting build-side values into hashmap    Concatenated build-side batch
 ///                                                                         ┌───────────────────────────┐
 ///                             hashmap.insert(row-hash, row-idx + offset)  │                      idx  │
diff --git a/datafusion/physical-plan/src/joins/hash_join/stream.rs b/datafusion/physical-plan/src/joins/hash_join/stream.rs
@@ -110,7 +110,7 @@ impl BuildSide {
 /// Expected state transitions performed by HashJoinStream are:
 ///
 /// ```text
-///
+/// 
 ///       WaitBuildSide
 ///             │
 ///             ▼
diff --git a/datafusion/physical-plan/src/sorts/cursor.rs b/datafusion/physical-plan/src/sorts/cursor.rs
@@ -52,7 +52,7 @@ pub trait CursorValues {
 /// [`CursorValues`]
 ///
 /// ```text
-///
+/// 
 /// ┌───────────────────────┐
 /// │                       │           ┌──────────────────────┐
 /// │ ┌─────────┐ ┌─────┐   │    ─ ─ ─ ─│      Cursor<T>       │
diff --git a/datafusion/physical-plan/src/unnest.rs b/datafusion/physical-plan/src/unnest.rs
@@ -591,7 +591,7 @@ struct UnnestingResult {
 /// ```
 /// Result:
 /// ```text
-///
+/// 
 ///     ┌────────────────────────────────────────────────┬────────────────────────────────────────────────┐
 ///     │ unnest(i, "recursive" := CAST('t' AS BOOLEAN)) │ unnest(j, "recursive" := CAST('t' AS BOOLEAN)) │
 ///     │                     int32                      │                     int32                      │
diff --git a/datafusion/spark/src/function/math/abs.rs b/datafusion/spark/src/function/math/abs.rs
@@ -36,7 +36,6 @@ use std::sync::Arc;
 /// TODOs:
 ///  - Spark's ANSI-compliant dialect, when off (i.e. `spark.sql.ansi.enabled=false`), taking absolute value on the minimal value of a signed integer returns the value as is. DataFusion's abs throws "DataFusion error: Arrow error: Compute error" on arithmetic overflow
 ///  - Spark's abs also supports ANSI interval types: YearMonthIntervalType and DayTimeIntervalType. DataFusion's abs doesn't.
-///
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub struct SparkAbs {
     signature: Signature,
diff --git a/datafusion/spark/src/function/url/url_decode.rs b/datafusion/spark/src/function/url/url_decode.rs
@@ -64,7 +64,6 @@ impl UrlDecode {
     ///
     /// * `Ok(String)` - The decoded string
     /// * `Err(DataFusionError)` - If the input is malformed or contains invalid UTF-8
-    ///
     fn decode(value: &str) -> Result<String> {
         // Check if the string has valid percent encoding
         Self::validate_percent_encoding(value)?;
@@ -170,7 +169,6 @@ impl ScalarUDFImpl for UrlDecode {
 ///
 /// * `Ok(ArrayRef)` - A new array of the same type containing decoded strings
 /// * `Err(DataFusionError)` - If validation fails or invalid arguments are provided
-///
 fn spark_url_decode(args: &[ArrayRef]) -> Result<ArrayRef> {
     spark_handled_url_decode(args, |x| x)
 }
diff --git a/datafusion/spark/src/function/url/url_encode.rs b/datafusion/spark/src/function/url/url_encode.rs
@@ -57,7 +57,6 @@ impl UrlEncode {
     /// # Returns
     ///
     /// * `Ok(String)` - The encoded string
-    ///
     fn encode(value: &str) -> Result<String> {
         Ok(byte_serialize(value.as_bytes()).collect::<String>())
     }
@@ -104,7 +103,6 @@ impl ScalarUDFImpl for UrlEncode {
 ///
 /// * `Ok(ArrayRef)` - A new array of the same type containing encoded strings
 /// * `Err(DataFusionError)` - If invalid arguments are provided
-///
 fn spark_url_encode(args: &[ArrayRef]) -> Result<ArrayRef> {
     if args.len() != 1 {
         return exec_err!("`url_encode` expects 1 argument");
diff --git a/datafusion/sql/src/unparser/mod.rs b/datafusion/sql/src/unparser/mod.rs
@@ -44,7 +44,7 @@ pub mod extension_unparser;
 /// use datafusion_sql::unparser::Unparser;
 /// let expr = col("a").gt(lit(4)); // form an expression `a > 4`
 /// let unparser = Unparser::default();
-/// let sql = unparser.expr_to_sql(&expr).unwrap();// convert to AST
+/// let sql = unparser.expr_to_sql(&expr).unwrap(); // convert to AST
 /// // use the Display impl to convert to SQL text
 /// assert_eq!(sql.to_string(), "(a > 4)");
 /// // now convert to pretty sql
