cargo fmt

gstvg · gstvg · commit d874db7e2881 · 2026-03-17T17:41:43.000-03:00
diff --git a/datafusion/core/src/bin/print_functions_docs.rs b/datafusion/core/src/bin/print_functions_docs.rs
@@ -18,7 +18,8 @@
 use datafusion::execution::SessionStateDefaults;
 use datafusion_common::{HashSet, Result, not_impl_err};
 use datafusion_expr::{
-    AggregateUDF, DocSection, Documentation, LambdaUDF, ScalarUDF, WindowUDF, aggregate_doc_sections, scalar_doc_sections, window_doc_sections
+    AggregateUDF, DocSection, Documentation, LambdaUDF, ScalarUDF, WindowUDF,
+    aggregate_doc_sections, scalar_doc_sections, window_doc_sections,
 };
 use itertools::Itertools;
 use std::env::args;
diff --git a/datafusion/core/src/execution/session_state.rs b/datafusion/core/src/execution/session_state.rs
@@ -57,12 +57,11 @@ use datafusion_expr::planner::ExprPlanner;
 #[cfg(feature = "sql")]
 use datafusion_expr::planner::{RelationPlanner, TypePlanner};
 use datafusion_expr::registry::{FunctionRegistry, SerializerRegistry};
+use datafusion_expr::simplify::SimplifyContext;
 #[cfg(feature = "sql")]
 use datafusion_expr::{
-    AggregateUDF, Explain, Expr, LambdaUDF, LogicalPlan, ScalarUDF,
-    WindowUDF,
+    AggregateUDF, Explain, Expr, LambdaUDF, LogicalPlan, ScalarUDF, WindowUDF,
 };
-use datafusion_expr::simplify::SimplifyContext;
 use datafusion_optimizer::simplify_expressions::ExprSimplifier;
 use datafusion_optimizer::{
     Analyzer, AnalyzerRule, Optimizer, OptimizerConfig, OptimizerRule,
diff --git a/datafusion/datasource-arrow/src/file_format.rs b/datafusion/datasource-arrow/src/file_format.rs
@@ -555,7 +555,9 @@ mod tests {
     use datafusion_execution::config::SessionConfig;
     use datafusion_execution::runtime_env::RuntimeEnv;
     use datafusion_expr::execution_props::ExecutionProps;
-    use datafusion_expr::{AggregateUDF, Expr, LambdaUDF, LogicalPlan, ScalarUDF, WindowUDF};
+    use datafusion_expr::{
+        AggregateUDF, Expr, LambdaUDF, LogicalPlan, ScalarUDF, WindowUDF,
+    };
     use datafusion_physical_expr_common::physical_expr::PhysicalExpr;
     use object_store::{chunked::ChunkedStore, memory::InMemory, path::Path};
 
@@ -601,7 +603,7 @@ mod tests {
         fn scalar_functions(&self) -> &HashMap<String, Arc<ScalarUDF>> {
             unimplemented!()
         }
-        
+
         fn lambda_functions(&self) -> &HashMap<String, Arc<dyn LambdaUDF>> {
             unimplemented!()
         }
diff --git a/datafusion/datasource/src/url.rs b/datafusion/datasource/src/url.rs
@@ -517,7 +517,9 @@ mod tests {
     use datafusion_execution::config::SessionConfig;
     use datafusion_execution::runtime_env::RuntimeEnv;
     use datafusion_expr::execution_props::ExecutionProps;
-    use datafusion_expr::{AggregateUDF, Expr, LambdaUDF, LogicalPlan, ScalarUDF, WindowUDF};
+    use datafusion_expr::{
+        AggregateUDF, Expr, LambdaUDF, LogicalPlan, ScalarUDF, WindowUDF,
+    };
     use datafusion_physical_expr_common::physical_expr::PhysicalExpr;
     use datafusion_physical_plan::ExecutionPlan;
     use object_store::{
diff --git a/datafusion/execution/src/task.rs b/datafusion/execution/src/task.rs
@@ -21,7 +21,7 @@ use crate::{
 };
 use datafusion_common::{Result, internal_datafusion_err, plan_datafusion_err};
 use datafusion_expr::planner::ExprPlanner;
-use datafusion_expr::{AggregateUDF, ScalarUDF, LambdaUDF, WindowUDF};
+use datafusion_expr::{AggregateUDF, LambdaUDF, ScalarUDF, WindowUDF};
 use std::collections::HashSet;
 use std::{collections::HashMap, sync::Arc};
 
diff --git a/datafusion/expr/src/expr.rs b/datafusion/expr/src/expr.rs
@@ -3410,9 +3410,7 @@ impl Display for SchemaDisplay<'_> {
                     SchemaDisplay(body)
                 )
             }
-            Expr::LambdaVariable(c) => {
-                f.write_str(&c.name)
-            }
+            Expr::LambdaVariable(c) => f.write_str(&c.name),
         }
     }
 }
diff --git a/datafusion/expr/src/expr_fn.rs b/datafusion/expr/src/expr_fn.rs
@@ -18,7 +18,9 @@
 //! Functions for creating logical expressions
 
 use crate::expr::{
-    AggregateFunction, BinaryExpr, Cast, Exists, GroupingSet, InList, InSubquery, Lambda, LambdaVariable, NullTreatment, Placeholder, TryCast, Unnest, WildcardOptions, WindowFunction
+    AggregateFunction, BinaryExpr, Cast, Exists, GroupingSet, InList, InSubquery, Lambda,
+    LambdaVariable, NullTreatment, Placeholder, TryCast, Unnest, WildcardOptions,
+    WindowFunction,
 };
 use crate::function::{
     AccumulatorArgs, AccumulatorFactoryFunction, PartitionEvaluatorFactory,
@@ -733,11 +735,14 @@ pub fn interval_month_day_nano_lit(value: &str) -> Expr {
 
 /// Create a lambda expression
 pub fn lambda(params: impl IntoIterator<Item = impl Into<String>>, body: Expr) -> Expr {
-    Expr::Lambda(Lambda::new(params.into_iter().map(Into::into).collect(), body))
+    Expr::Lambda(Lambda::new(
+        params.into_iter().map(Into::into).collect(),
+        body,
+    ))
 }
 
 /// Create an unresolved lambda variable expression
-/// 
+///
 /// The expression tree or [`LogicalPlan`] which
 /// owns this variable must be resolved before usage with either
 /// [`Expr::resolve_lambdas_variables`] or [`LogicalPlan::resolve_lambdas_variables`].
diff --git a/datafusion/expr/src/lib.rs b/datafusion/expr/src/lib.rs
@@ -128,7 +128,7 @@ pub use udaf::{
 };
 pub use udf::{ReturnFieldArgs, ScalarFunctionArgs, ScalarUDF, ScalarUDFImpl};
 pub use udlf::{
-    LambdaFunctionArgs, LambdaArgument, LambdaReturnFieldArgs, LambdaSignature,
+    LambdaArgument, LambdaFunctionArgs, LambdaReturnFieldArgs, LambdaSignature,
     LambdaTypeSignature, LambdaUDF, ValueOrLambda,
 };
 pub use udwf::{LimitEffect, ReversedUDWF, WindowUDF, WindowUDFImpl};
diff --git a/datafusion/expr/src/logical_plan/plan.rs b/datafusion/expr/src/logical_plan/plan.rs
@@ -41,7 +41,8 @@ use crate::logical_plan::display::{GraphvizVisitor, IndentVisitor};
 use crate::logical_plan::extension::UserDefinedLogicalNode;
 use crate::logical_plan::{DmlStatement, Statement};
 use crate::utils::{
-    enumerate_grouping_sets, exprlist_to_fields, find_out_reference_exprs, grouping_set_expr_count, grouping_set_to_exprlist, merge_schema, split_conjunction
+    enumerate_grouping_sets, exprlist_to_fields, find_out_reference_exprs,
+    grouping_set_expr_count, grouping_set_to_exprlist, merge_schema, split_conjunction,
 };
 use crate::{
     BinaryExpr, CreateMemoryTable, CreateView, Execute, Expr, ExprSchemable,
@@ -2111,7 +2112,7 @@ impl LogicalPlan {
     }
 
     /// Return a `LogicalPLan` with all [`LambdaVariable`] resolved
-    /// 
+    ///
     /// [`LambdaVariable`]: crate::expr::LambdaVariable
     pub fn resolve_lambdas_variables(self) -> Result<Transformed<LogicalPlan>> {
         self.transform_with_subqueries(|plan| {
diff --git a/datafusion/expr/src/planner.rs b/datafusion/expr/src/planner.rs
@@ -24,7 +24,8 @@ use crate::expr::NullTreatment;
 #[cfg(feature = "sql")]
 use crate::logical_plan::LogicalPlan;
 use crate::{
-    AggregateUDF, Expr, GetFieldAccess, LambdaUDF, ScalarUDF, SortExpr, TableSource, WindowFrame, WindowFunctionDefinition, WindowUDF
+    AggregateUDF, Expr, GetFieldAccess, LambdaUDF, ScalarUDF, SortExpr, TableSource,
+    WindowFrame, WindowFunctionDefinition, WindowUDF,
 };
 use arrow::datatypes::{DataType, Field, FieldRef, SchemaRef};
 use datafusion_common::datatype::DataTypeExt;
@@ -101,7 +102,7 @@ pub trait ContextProvider {
 
     /// Return the scalar function with a given name, if any
     fn get_function_meta(&self, name: &str) -> Option<Arc<ScalarUDF>>;
-    
+
     /// Return the lambda function with a given name, if any
     fn get_lambda_meta(&self, name: &str) -> Option<Arc<dyn LambdaUDF>>;
 
@@ -132,7 +133,7 @@ pub trait ContextProvider {
 
     /// Return all scalar function names
     fn udf_names(&self) -> Vec<String>;
-    
+
     /// Return all lambda function names
     fn udlf_names(&self) -> Vec<String>;
 
diff --git a/datafusion/expr/src/udlf.rs b/datafusion/expr/src/udlf.rs
@@ -23,7 +23,7 @@ use crate::{ColumnarValue, Documentation, Expr};
 use arrow::array::{ArrayRef, RecordBatch};
 use arrow::datatypes::{DataType, Field, FieldRef, Schema};
 use datafusion_common::config::ConfigOptions;
-use datafusion_common::{exec_err, not_impl_err, Result, ScalarValue};
+use datafusion_common::{Result, ScalarValue, exec_err, not_impl_err};
 use datafusion_expr_common::dyn_eq::{DynEq, DynHash};
 use datafusion_expr_common::signature::Volatility;
 use datafusion_physical_expr_common::physical_expr::PhysicalExpr;
@@ -148,7 +148,8 @@ impl PartialOrd for dyn LambdaUDF {
             "Detected incorrect implementation of PartialEq when comparing functions: '{}' and '{}'. \
             The functions compare as equal, but they are not equal based on general properties that \
             the PartialOrd implementation observes,",
-            self.name(), other.name()
+            self.name(),
+            other.name()
         );
         Some(cmp)
     }
@@ -169,8 +170,8 @@ pub struct LambdaFunctionArgs {
     /// The evaluated arguments and lambdas to the function
     pub args: Vec<ValueOrLambda<ColumnarValue, LambdaArgument>>,
     /// Field associated with each arg, if it exists
-    /// For lambdas, it will be the field of the result of 
-    /// the lambda if evaluated with the parameters 
+    /// For lambdas, it will be the field of the result of
+    /// the lambda if evaluated with the parameters
     /// returned from [`LambdaUDF::lambdas_parameters`]
     pub arg_fields: Vec<ValueOrLambda<FieldRef, FieldRef>>,
     /// The number of rows in record batch being evaluated
@@ -447,14 +448,14 @@ pub trait LambdaUDF: Debug + DynEq + DynHash + Send + Sync {
     }
 
     /// Returns a list of the same size as args where each value is the logic below applied to value at the correspondent position in args:
-    /// 
+    ///
     /// If it's a value, return None
     /// If it's a lambda, return the list of all parameters that that lambda supports
-    /// 
+    ///
     /// Example for array_transform:
-    /// 
+    ///
     /// `array_transform([2.0, 8.0], v -> v > 4.0)`
-    /// 
+    ///
     /// ```ignore
     /// let lambdas_parameters = array_transform.lambdas_parameters(&[
     ///      ValueOrLambdaParameter::Value(Field::new("", DataType::new_list(DataType::Float32, false)))]), // the Field of the literal `[2, 8]`
@@ -470,14 +471,14 @@ pub trait LambdaUDF: Debug + DynEq + DynHash + Send + Sync {
     ///         Some(vec![
     ///             // the value being transformed
     ///             Field::new("", DataType::Float32, false),
-    ///             // the 1-based index being transformed, not used on the example above, 
+    ///             // the 1-based index being transformed, not used on the example above,
     ///             //but implementations doesn't need to care about it
     ///             Field::new("", DataType::Int32, false),
     ///         ])
     ///      ]
     /// )
     /// ```
-    /// 
+    ///
     /// The implementation can assume that some other part of the code has coerced
     /// the actual argument types to match [`Self::signature`].
     fn lambdas_parameters(
@@ -486,7 +487,7 @@ pub trait LambdaUDF: Debug + DynEq + DynHash + Send + Sync {
     ) -> Result<Vec<Option<Vec<Field>>>>;
 
     /// What type will be returned by this function, given the arguments?
-    /// 
+    ///
     /// The implementation can assume that some other part of the code has coerced
     /// the actual argument types to match [`Self::signature`].
     ///
diff --git a/datafusion/functions-nested/src/array_transform.rs b/datafusion/functions-nested/src/array_transform.rs
@@ -23,12 +23,11 @@ use arrow::{
     datatypes::{DataType, Field, FieldRef},
 };
 use datafusion_common::{
-    exec_err, plan_err,
+    Result, exec_err, plan_err,
     utils::{
         adjust_offsets_for_slice, list_values, list_values_index, list_values_row_number,
         take_function_args,
     },
-    Result,
 };
 use datafusion_expr::{
     ColumnarValue, Documentation, LambdaFunctionArgs, LambdaReturnFieldArgs,
@@ -118,7 +117,7 @@ impl LambdaUDF for ArrayTransform {
                     "{} expected a list as first argument, got {}",
                     self.name(),
                     list
-                )
+                );
             }
         };
 
@@ -175,7 +174,7 @@ impl LambdaUDF for ArrayTransform {
         let (list, lambda) = value_lambda_pair(self.name(), &args.args)?;
 
         let list_array = list.to_array(args.number_rows)?;
-        
+
         // as per list_values docs, if list_array is sliced, list_values will be sliced too,
         // so before constructing the transformed array below, we must adjust the list offsets with
         // adjust_offsets_for_slice
@@ -210,7 +209,7 @@ impl LambdaUDF for ArrayTransform {
                     "{} expected ScalarFunctionArgs.return_field to be a list, got {}",
                     self.name(),
                     args.return_field
-                )
+                );
             }
         };
 
diff --git a/datafusion/optimizer/tests/optimizer_integration.rs b/datafusion/optimizer/tests/optimizer_integration.rs
@@ -735,7 +735,10 @@ impl ContextProvider for MyContextProvider {
         None
     }
 
-    fn get_lambda_meta(&self, _name: &str) -> Option<Arc<dyn datafusion_expr::LambdaUDF>> {
+    fn get_lambda_meta(
+        &self,
+        _name: &str,
+    ) -> Option<Arc<dyn datafusion_expr::LambdaUDF>> {
         None
     }
 
diff --git a/datafusion/physical-expr/src/expressions/lambda_variable.rs b/datafusion/physical-expr/src/expressions/lambda_variable.rs
@@ -28,7 +28,7 @@ use arrow::{
     record_batch::RecordBatch,
 };
 
-use datafusion_common::{exec_err, Result};
+use datafusion_common::{Result, exec_err};
 use datafusion_expr::ColumnarValue;
 
 /// Represents the lambda variable with a given name and field
@@ -56,10 +56,7 @@ impl Hash for LambdaVariable {
 impl LambdaVariable {
     /// Create a new lambda variable expression
     pub fn new(name: String, field: FieldRef) -> Self {
-        Self {
-            name,
-            field,
-        }
+        Self { name, field }
     }
 
     /// Get the variable's name
@@ -120,6 +117,9 @@ impl PhysicalExpr for LambdaVariable {
 }
 
 /// Create a lambda variable expression
-pub fn lambda_variable(name: impl Into<String>, field: FieldRef) -> Result<Arc<dyn PhysicalExpr>> {
+pub fn lambda_variable(
+    name: impl Into<String>,
+    field: FieldRef,
+) -> Result<Arc<dyn PhysicalExpr>> {
     Ok(Arc::new(LambdaVariable::new(name.into(), field)))
 }
diff --git a/datafusion/physical-expr/src/expressions/mod.rs b/datafusion/physical-expr/src/expressions/mod.rs
@@ -27,8 +27,8 @@ mod dynamic_filters;
 mod in_list;
 mod is_not_null;
 mod is_null;
-mod lambda_variable;
 mod lambda;
+mod lambda_variable;
 mod like;
 mod literal;
 mod negative;
@@ -51,8 +51,8 @@ pub use dynamic_filters::DynamicFilterPhysicalExpr;
 pub use in_list::{InListExpr, in_list};
 pub use is_not_null::{IsNotNullExpr, is_not_null};
 pub use is_null::{IsNullExpr, is_null};
-pub use lambda_variable::{lambda_variable, LambdaVariable};
 pub use lambda::{LambdaExpr, lambda};
+pub use lambda_variable::{LambdaVariable, lambda_variable};
 pub use like::{LikeExpr, like};
 pub use literal::{Literal, lit};
 pub use negative::{NegativeExpr, negative};
diff --git a/datafusion/physical-expr/src/lib.rs b/datafusion/physical-expr/src/lib.rs
@@ -32,10 +32,10 @@ pub mod binary_map {
     pub use datafusion_physical_expr_common::binary_map::{ArrowBytesSet, OutputType};
 }
 pub mod async_scalar_function;
-pub mod lambda_function;
 pub mod equivalence;
 pub mod expressions;
 pub mod intervals;
+pub mod lambda_function;
 mod partitioning;
 mod physical_expr;
 pub mod planner;
@@ -70,9 +70,9 @@ pub use datafusion_physical_expr_common::sort_expr::{
     PhysicalSortRequirement,
 };
 
+pub use lambda_function::LambdaFunctionExpr;
 pub use planner::{create_physical_expr, create_physical_exprs};
 pub use scalar_function::ScalarFunctionExpr;
-pub use lambda_function::LambdaFunctionExpr;
 pub use simplifier::PhysicalExprSimplifier;
 pub use utils::{conjunction, conjunction_opt, split_conjunction};
 
diff --git a/datafusion/proto/src/bytes/registry.rs b/datafusion/proto/src/bytes/registry.rs
@@ -39,7 +39,9 @@ impl FunctionRegistry for NoRegistry {
     }
 
     fn udlf(&self, name: &str) -> Result<Arc<dyn datafusion_expr::LambdaUDF>> {
-        plan_err!("No function registry provided to deserialize, so can not deserialize User Defined Lambda Function '{name}'")
+        plan_err!(
+            "No function registry provided to deserialize, so can not deserialize User Defined Lambda Function '{name}'"
+        )
     }
 
     fn udaf(&self, name: &str) -> Result<Arc<AggregateUDF>> {
diff --git a/datafusion/proto/src/logical_plan/to_proto.rs b/datafusion/proto/src/logical_plan/to_proto.rs
@@ -629,7 +629,7 @@ pub fn serialize_expr(
         Expr::LambdaFunction(_) | Expr::Lambda(_) | Expr::LambdaVariable(_) => {
             return Err(Error::General(
                 "Proto serialization error: Lambda not implemented".to_string(),
-            ))
+            ));
         }
     };
 
diff --git a/datafusion/session/src/session.rs b/datafusion/session/src/session.rs
@@ -109,7 +109,7 @@ pub trait Session: Send + Sync {
 
     /// Return reference to scalar_functions
     fn scalar_functions(&self) -> &HashMap<String, Arc<ScalarUDF>>;
-    
+
     /// Return reference to lambda_functions
     fn lambda_functions(&self) -> &HashMap<String, Arc<dyn LambdaUDF>>;
 
diff --git a/datafusion/sql/src/expr/function.rs b/datafusion/sql/src/expr/function.rs
diff --git a/datafusion/sql/src/unparser/dialect.rs b/datafusion/sql/src/unparser/dialect.rs
diff --git a/datafusion/sql/tests/common/mod.rs b/datafusion/sql/tests/common/mod.rs
diff --git a/datafusion/substrait/src/logical_plan/consumer/expr/scalar_function.rs b/datafusion/substrait/src/logical_plan/consumer/expr/scalar_function.rs
diff --git a/datafusion/substrait/src/logical_plan/producer/expr/mod.rs b/datafusion/substrait/src/logical_plan/producer/expr/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -3410,9 +3410,7 @@ impl Display for SchemaDisplay<'_> {`
`3410`	`3410`	`SchemaDisplay(body)`
`3411`	`3411`	`)`
`3412`	`3412`	`}`
`3413`		`- Expr::LambdaVariable(c) => {`
`3414`		`- f.write_str(&c.name)`
`3415`		`- }`
	`3413`	`+ Expr::LambdaVariable(c) => f.write_str(&c.name),`
`3416`	`3414`	`}`
`3417`	`3415`	`}`
`3418`	`3416`	`}`