fix typos

Author: adriangb

datafusion/expr-common/src/placement.rs

@@ -61,7 +61,7 @@ pub enum ExpressionPlacement {
     /// leaf-pushable expression, then it would return this variant.
     /// Then `other_leaf_function(get_field(...), 42)` could also be classified as
     /// leaf-pushable using the knowledge that `get_field(...)` is leaf-pushable.
-    PlaceAtLeafs,
+    PlaceAtLeaves,
     /// Argument is a complex expression that should be placed at root nodes.
     /// For example, `min(col1 + col2)` is not leaf-pushable because it requires per-row computation.
     PlaceAtRoot,

datafusion/expr/src/udf.rs

@@ -133,10 +133,7 @@ impl ScalarUDF {
     /// as further up the tree so that it can be run after filtering, sorting, etc.
     ///
     /// See [`ScalarUDFImpl::placement`] for more details.
-    pub fn placement(
-        &self,
-        args: &[ExpressionPlacement],
-    ) -> ExpressionPlacement {
+    pub fn placement(&self, args: &[ExpressionPlacement]) -> ExpressionPlacement {
         self.inner.placement(args)
     }
 

datafusion/functions/src/core/getfield.rs

@@ -502,18 +502,18 @@ impl ScalarUDFImpl for GetFieldFunc {
 
     fn placement(&self, args: &[ExpressionPlacement]) -> ExpressionPlacement {
         // get_field is leaf-pushable if:
-        // 1. The struct/map argument is a Column or PlaceAtLeafs (not Literal or PlaceAtRoot)
+        // 1. The struct/map argument is a Column or PlaceAtLeaves (not Literal or PlaceAtRoot)
         // 2. All key arguments are literals (static field access, not dynamic per-row lookup)
         //
         // Literal base is not considered leaf-pushable because it would be constant-folded anyway.
         if args.is_empty() {
             return ExpressionPlacement::PlaceAtRoot;
         }
 
-        // Check if the base (struct/map) argument is Column or PlaceAtLeafs
+        // Check if the base (struct/map) argument is Column or PlaceAtLeaves
         if !matches!(
             args[0],
-            ExpressionPlacement::Column | ExpressionPlacement::PlaceAtLeafs
+            ExpressionPlacement::Column | ExpressionPlacement::PlaceAtLeaves
         ) {
             return ExpressionPlacement::PlaceAtRoot;
         }
@@ -525,7 +525,7 @@ impl ScalarUDFImpl for GetFieldFunc {
             .all(|a| *a == ExpressionPlacement::Literal);
 
         if keys_literal {
-            ExpressionPlacement::PlaceAtLeafs
+            ExpressionPlacement::PlaceAtLeaves
         } else {
             ExpressionPlacement::PlaceAtRoot
         }
@@ -580,22 +580,22 @@ mod tests {
 
         // get_field(col, 'literal') -> leaf-pushable (static field access)
         let args = vec![ExpressionPlacement::Column, ExpressionPlacement::Literal];
-        assert_eq!(func.placement(&args), ExpressionPlacement::PlaceAtLeafs);
+        assert_eq!(func.placement(&args), ExpressionPlacement::PlaceAtLeaves);
 
         // get_field(col, 'a', 'b') -> leaf-pushable (nested static field access)
         let args = vec![
             ExpressionPlacement::Column,
             ExpressionPlacement::Literal,
             ExpressionPlacement::Literal,
         ];
-        assert_eq!(func.placement(&args), ExpressionPlacement::PlaceAtLeafs);
+        assert_eq!(func.placement(&args), ExpressionPlacement::PlaceAtLeaves);
 
-        // get_field(get_field(col, 'a'), 'b') represented as PlaceAtLeafs for base
+        // get_field(get_field(col, 'a'), 'b') represented as PlaceAtLeaves for base
         let args = vec![
-            ExpressionPlacement::PlaceAtLeafs,
+            ExpressionPlacement::PlaceAtLeaves,
             ExpressionPlacement::Literal,
         ];
-        assert_eq!(func.placement(&args), ExpressionPlacement::PlaceAtLeafs);
+        assert_eq!(func.placement(&args), ExpressionPlacement::PlaceAtLeaves);
     }
 
     #[test]
@@ -641,9 +641,9 @@ mod tests {
         // Empty args -> NOT leaf-pushable
         assert_eq!(func.placement(&[]), ExpressionPlacement::PlaceAtRoot);
 
-        // Just base, no key -> PlaceAtLeafs (not a valid call but should handle gracefully)
+        // Just base, no key -> PlaceAtLeaves (not a valid call but should handle gracefully)
         let args = vec![ExpressionPlacement::Column];
-        assert_eq!(func.placement(&args), ExpressionPlacement::PlaceAtLeafs);
+        assert_eq!(func.placement(&args), ExpressionPlacement::PlaceAtLeaves);
 
         // Literal base with literal key -> NOT leaf-pushable (would be constant-folded)
         let args = vec![ExpressionPlacement::Literal, ExpressionPlacement::Literal];

datafusion/physical-expr-common/src/physical_expr.rs

@@ -437,13 +437,13 @@ pub trait PhysicalExpr: Any + Send + Sync + Display + Debug + DynEq + DynHash {
     /// Leaf-pushable expressions include:
     /// - Column references (`ExpressionPlacement::Column`)
     /// - Literal values (`ExpressionPlacement::Literal`)
-    /// - Struct field access via `get_field` (`ExpressionPlacement::PlaceAtLeafs`)
+    /// - Struct field access via `get_field` (`ExpressionPlacement::PlaceAtLeaves`)
     /// - Nested combinations of field accessors (e.g., `col['a']['b']`)
     ///
     /// This is used to identify expressions that are cheap to duplicate or
     /// don't benefit from caching/partitioning optimizations.
     ///
-    /// **Performance note**: Expressions marked as `PlaceAtLeafs` may be pushed
+    /// **Performance note**: Expressions marked as `PlaceAtLeaves` may be pushed
     /// below filters during optimization. If an expression does per-row work,
     /// marking it leaf-pushable may slow things down by causing evaluation on more rows.
     fn placement(&self) -> ExpressionPlacement {

datafusion/physical-optimizer/src/projection_pushdown.rs

@@ -132,12 +132,12 @@ fn try_split_projection(
         }
 
         // Only extract from root-level expressions. If the entire expression is
-        // already PlaceAtLeafs (like `get_field(col, 'foo')`), it can be pushed as-is.
+        // already PlaceAtLeaves (like `get_field(col, 'foo')`), it can be pushed as-is.
         // We only need to split when there's a root expression with leaf-pushable
         // sub-expressions (like `get_field(col, 'foo') + 1`).
         if matches!(
             proj_expr.expr.placement(),
-            ExpressionPlacement::PlaceAtLeafs
+            ExpressionPlacement::PlaceAtLeaves
         ) {
             outer_exprs.push(proj_expr.clone());
             continue;
@@ -180,7 +180,7 @@ fn try_split_projection(
 /// Extracts beneficial leaf-pushable sub-expressions from larger expressions.
 ///
 /// Similar to `JoinFilterRewriter`, this struct walks expression trees top-down
-/// and extracts sub-expressions where `placement() == ExpressionPlacement::PlaceAtLeafs`
+/// and extracts sub-expressions where `placement() == ExpressionPlacement::PlaceAtLeaves`
 /// (beneficial leaf-pushable expressions like field accessors).
 ///
 /// The extracted expressions are replaced with column references pointing to
@@ -212,7 +212,7 @@ impl<'a> LeafExpressionExtractor<'a> {
     /// sub-expressions with column references to the inner projection.
     fn extract(&mut self, expr: Arc<dyn PhysicalExpr>) -> Result<Arc<dyn PhysicalExpr>> {
         // Top-down: check self first, then recurse to children
-        if matches!(expr.placement(), ExpressionPlacement::PlaceAtLeafs) {
+        if matches!(expr.placement(), ExpressionPlacement::PlaceAtLeaves) {
             // Extract this entire sub-tree
             return Ok(self.add_extracted_expr(expr));
         }

datafusion/physical-plan/src/projection.rs

@@ -254,13 +254,13 @@ impl ProjectionExec {
     ///
     /// This is true when:
     /// - The projection narrows the schema (drops columns) - saves memory, OR
-    /// - Any expression is PlaceAtLeafs (like get_field) - beneficial computation pushdown
+    /// - Any expression is PlaceAtLeaves (like get_field) - beneficial computation pushdown
     ///
     /// Pure Column references that don't narrow the schema are NOT beneficial to push,
     /// as they just rearrange the plan without any gain.
     ///
     /// Note: Projections are split by `try_split_projection` before reaching this function,
-    /// so if any expression is PlaceAtLeafs, all expressions should be leaf-pushable.
+    /// so if any expression is PlaceAtLeaves, all expressions should be leaf-pushable.
     pub fn is_leaf_pushable_or_narrows_schema(&self) -> bool {
         let all_columns = self
             .expr()
@@ -272,7 +272,7 @@ impl ProjectionExec {
         let has_leaf_expressions = self
             .expr()
             .iter()
-            .any(|p| matches!(p.expr.placement(), ExpressionPlacement::PlaceAtLeafs));
+            .any(|p| matches!(p.expr.placement(), ExpressionPlacement::PlaceAtLeaves));
 
         let has_root_expressions = self.expr().iter().any(|p| {
             matches!(
@@ -1152,14 +1152,14 @@ fn try_unifying_projections(
     // Don't merge if:
     // 1. A non-trivial expression is referenced more than once (caching benefit)
     //    See discussion in: https://github.com/apache/datafusion/issues/8296
-    // 2. The child projection has PlaceAtLeafs (like get_field) that should be pushed
+    // 2. The child projection has PlaceAtLeaves (like get_field) that should be pushed
     //    down to the data source separately
     for (column, count) in column_ref_map.iter() {
         let placement = child.expr()[column.index()].expr.placement();
         // Don't merge if multi-referenced root level (caching)
         if (*count > 1 && matches!(placement, ExpressionPlacement::PlaceAtRoot))
-            // Don't merge if child has PlaceAtLeafs (should push to source)
-            || matches!(placement, ExpressionPlacement::PlaceAtLeafs)
+            // Don't merge if child has PlaceAtLeaves (should push to source)
+            || matches!(placement, ExpressionPlacement::PlaceAtLeaves)
         {
             return Ok(None);
         }