chore: Format examples in doc strings - functions (#18353)

## Which issue does this PR close?
Part of #16915

## Rationale for this change
Format code examples in documentation comments to improve readability
and maintain consistent code style across the codebase. This is part of
a multi-PR effort to format all doc comment examples and eventually
enable CI checks to enforce this formatting.

## What changes are included in this PR?
Run `cargo fmt -p <crate> -- --config format_code_in_doc_comments=true`
for the following datasource-related crates:
  - `datafusion-functions`
  - `datafusion-functions-aggregate`
  - `datafusion-functions-aggregate-common`
  - `datafusion-functions-nested`
  - `datafusion-functions-table`
  - `datafusion-functions-window`
  - `datafusion-functions-window-common`

## Are these changes tested?
No testing needed - this is purely a formatting change with no
functional modifications.

## Are there any user-facing changes?
No - this only affects documentation formatting.

Author: CuteChuanChuan

datafusion/functions-aggregate-common/src/aggregate/groups_accumulator.rs

@@ -80,15 +80,13 @@ use datafusion_expr_common::groups_accumulator::{EmitTo, GroupsAccumulator};
 ///  Logical group         Current Min/Max value for that group stored
 ///     number             as a ScalarValue which points to an
 ///                        individually allocated String
-///
-///```
+/// ```
 ///
 /// # Optimizations
 ///
 /// The adapter minimizes the number of calls to [`Accumulator::update_batch`]
 /// by first collecting the input rows for each group into a contiguous array
 /// using [`compute::take`]
-///
 pub struct GroupsAccumulatorAdapter {
     factory: Box<dyn Fn() -> Result<Box<dyn Accumulator>> + Send>,
 
@@ -184,7 +182,6 @@ impl GroupsAccumulatorAdapter {
     /// └─────────┘   └─────────┘   └ ─ ─ ─ ─ ┘                       └─────────┘   └ ─ ─ ─ ─ ┘
     ///
     /// logical group   values      opt_filter           logical group  values       opt_filter
-    ///
     /// ```
     fn invoke_per_accumulator<F>(
         &mut self,

datafusion/functions-aggregate-common/src/aggregate/groups_accumulator/accumulate.rs

@@ -760,7 +760,6 @@ mod test {
 
         /// Calls `NullState::accumulate` and `accumulate_indices` to
         /// ensure it generates the correct values.
-        ///
         fn accumulate_test(
             group_indices: &[usize],
             values: &UInt32Array,

datafusion/functions-aggregate-common/src/aggregate/groups_accumulator/prim_op.rs

@@ -142,7 +142,6 @@ where
     /// The state is:
     /// - self.prim_fn for all non null, non filtered values
     /// - null otherwise
-    ///
     fn convert_to_state(
         &self,
         values: &[ArrayRef],

datafusion/functions-aggregate-common/src/tdigest.rs

@@ -575,7 +575,6 @@ impl TDigest {
     ///                          │└ ─ ─ ─ ┘│
     ///                          │         │
     ///                              ...
-    ///
     /// ```
     ///
     /// The [`TDigest::from_scalar_state()`] method reverses this processes,

datafusion/functions-aggregate/src/count.rs

@@ -113,8 +113,8 @@ pub fn count_all() -> Expr {
 /// // create `count(*)` OVER ... window function expression
 /// let expr = count_all_window();
 /// assert_eq!(
-///   expr.schema_name().to_string(),
-///   "count(Int64(1)) ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING"
+///     expr.schema_name().to_string(),
+///     "count(Int64(1)) ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING"
 /// );
 /// // if you need to refer to this column, use the `schema_name` function
 /// let expr = col(expr.schema_name().to_string());

datafusion/functions-aggregate/src/median.rs

@@ -302,7 +302,6 @@ impl<T: ArrowNumericType> Accumulator for MedianAccumulator<T> {
 /// of groups before final evaluation.
 /// So values in each group will be stored in a `Vec<T>`, and the total group values
 /// will be actually organized as a `Vec<Vec<T>>`.
-///
 #[derive(Debug)]
 struct MedianGroupsAccumulator<T: ArrowNumericType + Send> {
     data_type: DataType,

datafusion/functions-aggregate/src/percentile_cont.rs

@@ -457,7 +457,6 @@ impl<T: ArrowNumericType> Accumulator for PercentileContAccumulator<T> {
 /// of groups before final evaluation.
 /// So values in each group will be stored in a `Vec<T>`, and the total group values
 /// will be actually organized as a `Vec<Vec<T>>`.
-///
 #[derive(Debug)]
 struct PercentileContGroupsAccumulator<T: ArrowNumericType + Send> {
     data_type: DataType,

datafusion/functions-nested/src/expr_ext.rs

@@ -36,8 +36,7 @@ use crate::extract::{array_element, array_slice};
 /// ```
 /// # use datafusion_expr::{lit, col, Expr};
 /// # use datafusion_functions_nested::expr_ext::IndexAccessor;
-/// let expr = col("c1")
-///    .index(lit(3));
+/// let expr = col("c1").index(lit(3));
 /// assert_eq!(expr.schema_name().to_string(), "c1[Int32(3)]");
 /// ```
 pub trait IndexAccessor {
@@ -66,8 +65,7 @@ impl IndexAccessor for Expr {
 /// ```
 /// # use datafusion_expr::{lit, col};
 /// # use datafusion_functions_nested::expr_ext::SliceAccessor;
-/// let expr = col("c1")
-///    .range(lit(2), lit(4));
+/// let expr = col("c1").range(lit(2), lit(4));
 /// assert_eq!(expr.schema_name().to_string(), "c1[Int32(2):Int32(4)]");
 /// ```
 pub trait SliceAccessor {

datafusion/functions-nested/src/lib.rs

@@ -32,7 +32,6 @@
 //! [DataFusion]: https://crates.io/crates/datafusion
 //!
 //! You can register the functions in this crate using the [`register_all`] function.
-//!
 
 #[macro_use]
 pub mod macros;

datafusion/functions-window-common/src/expr.rs

@@ -39,7 +39,6 @@ impl<'a> ExpressionArgs<'a> {
     ///   to the user-defined window function.
     /// * `input_fields` - The fields corresponding to the
     ///   arguments to the user-defined window function.
-    ///
     pub fn new(
         input_exprs: &'a [Arc<dyn PhysicalExpr>],
         input_fields: &'a [FieldRef],