Refactor Expr::GetIndexedField to use a struct

datafusion/core/src/physical_plan/planner.rs

@@ -174,9 +174,9 @@ fn create_physical_name(e: &Expr, is_first_expr: bool) -> Result<String> {
             let expr = create_physical_name(expr, false)?;
             Ok(format!("{} IS NOT UNKNOWN", expr))
         }
-        Expr::GetIndexedField { expr, key } => {
-            let expr = create_physical_name(expr, false)?;
-            Ok(format!("{}[{}]", expr, key))
+        Expr::GetIndexedField(get_indexed_field) => {
+            let expr = create_physical_name(&get_indexed_field.expr, false)?;
+            Ok(format!("{}[{}]", expr, get_indexed_field.key))
         }
         Expr::ScalarFunction { fun, args, .. } => {
             create_function_physical_name(&fun.to_string(), false, args)

datafusion/expr/src/expr.rs

@@ -142,12 +142,7 @@ pub enum Expr {
     /// arithmetic negation of an expression, the operand must be of a signed numeric data type
     Negative(Box<Expr>),
     /// Returns the field of a [`arrow::array::ListArray`] or [`arrow::array::StructArray`] by key
-    GetIndexedField {
-        /// the expression to take the field from
-        expr: Box<Expr>,
-        /// The name of the field to take
-        key: ScalarValue,
-    },
+    GetIndexedField(GetIndexedField),
     /// Whether an expression is between a given range.
     Between {
         /// The value to compare
@@ -285,6 +280,14 @@ pub enum Expr {
     GroupingSet(GroupingSet),
 }
 
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct GetIndexedField {
+    /// the expression to take the field from
+    pub expr: Box<Expr>,
+    /// The name of the field to take
+    pub key: ScalarValue,
+}
+
 /// CASE expression
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct Case {
@@ -831,8 +834,12 @@ impl fmt::Debug for Expr {
             }
             Expr::Wildcard => write!(f, "*"),
             Expr::QualifiedWildcard { qualifier } => write!(f, "{}.*", qualifier),
-            Expr::GetIndexedField { ref expr, key } => {
-                write!(f, "({:?})[{}]", expr, key)
+            Expr::GetIndexedField(get_indexed_field) => {
+                write!(
+                    f,
+                    "({:?})[{}]",
+                    get_indexed_field.expr, get_indexed_field.key
+                )
             }
             Expr::GroupingSet(grouping_sets) => match grouping_sets {
                 GroupingSet::Rollup(exprs) => {
@@ -1059,9 +1066,9 @@ fn create_name(e: &Expr) -> Result<String> {
         Expr::ScalarSubquery(subquery) => {
             Ok(subquery.subquery.schema().field(0).name().clone())
         }
-        Expr::GetIndexedField { expr, key } => {
-            let expr = create_name(expr)?;
-            Ok(format!("{}[{}]", expr, key))
+        Expr::GetIndexedField(get_indexed_field) => {
+            let expr = create_name(&get_indexed_field.expr)?;
+            Ok(format!("{}[{}]", expr, get_indexed_field.key))
         }
         Expr::ScalarFunction { fun, args, .. } => {
             create_function_name(&fun.to_string(), false, args)

datafusion/expr/src/expr_rewriter.rs

@@ -17,7 +17,7 @@
 
 //! Expression rewriter
 
-use crate::expr::{Case, GroupingSet};
+use crate::expr::{Case, GetIndexedField, GroupingSet};
 use crate::logical_plan::{Aggregate, Projection};
 use crate::utils::{from_plan, grouping_set_to_exprlist};
 use crate::{Expr, ExprSchemable, LogicalPlan};
@@ -284,10 +284,12 @@ impl ExprRewritable for Expr {
             Expr::QualifiedWildcard { qualifier } => {
                 Expr::QualifiedWildcard { qualifier }
             }
-            Expr::GetIndexedField { expr, key } => Expr::GetIndexedField {
-                expr: rewrite_boxed(expr, rewriter)?,
-                key,
-            },
+            Expr::GetIndexedField(get_indexed_field) => {
+                Expr::GetIndexedField(GetIndexedField {
+                    expr: rewrite_boxed(get_indexed_field.expr, rewriter)?,
+                    key: get_indexed_field.key,
+                })
+            }
         };
 
         // now rewrite this expression itself

datafusion/expr/src/expr_schema.rs

@@ -137,10 +137,11 @@ impl ExprSchemable for Expr {
                 // grouping sets do not really have a type and do not appear in projections
                 Ok(DataType::Null)
             }
-            Expr::GetIndexedField { ref expr, key } => {
-                let data_type = expr.get_type(schema)?;
+            Expr::GetIndexedField(indexed_field) => {
+                let data_type = indexed_field.expr.get_type(schema)?;
 
-                get_indexed_field(&data_type, key).map(|x| x.data_type().clone())
+                get_indexed_field(&data_type, &indexed_field.key)
+                    .map(|x| x.data_type().clone())
             }
         }
     }
@@ -217,9 +218,9 @@ impl ExprSchemable for Expr {
                 "QualifiedWildcard expressions are not valid in a logical query plan"
                     .to_owned(),
             )),
-            Expr::GetIndexedField { ref expr, key } => {
-                let data_type = expr.get_type(input_schema)?;
-                get_indexed_field(&data_type, key).map(|x| x.is_nullable())
+            Expr::GetIndexedField(indexed_field) => {
+                let data_type = indexed_field.expr.get_type(input_schema)?;
+                get_indexed_field(&data_type, &indexed_field.key).map(|x| x.is_nullable())
             }
             Expr::GroupingSet(_) => {
                 // grouping sets do not really have the concept of nullable and do not appear

datafusion/expr/src/expr_visitor.rs

@@ -108,8 +108,10 @@ impl ExprVisitable for Expr {
             | Expr::Cast { expr, .. }
             | Expr::TryCast { expr, .. }
             | Expr::Sort { expr, .. }
-            | Expr::InSubquery { expr, .. }
-            | Expr::GetIndexedField { expr, .. } => expr.accept(visitor),
+            | Expr::InSubquery { expr, .. } => expr.accept(visitor),
+            Expr::GetIndexedField(get_indexed_field) => {
+                get_indexed_field.expr.accept(visitor)
+            }
             Expr::GroupingSet(GroupingSet::Rollup(exprs)) => exprs
                 .iter()
                 .fold(Ok(visitor), |v, e| v.and_then(|v| e.accept(v))),

datafusion/expr/src/lib.rs

@@ -56,7 +56,7 @@ pub use accumulator::{Accumulator, AggregateState};
 pub use aggregate_function::AggregateFunction;
 pub use built_in_function::BuiltinScalarFunction;
 pub use columnar_value::{ColumnarValue, NullColumnarValue};
-pub use expr::{Case, Expr, GroupingSet};
+pub use expr::{Case, Expr, GetIndexedField, GroupingSet};
 pub use expr_fn::*;
 pub use expr_schema::ExprSchemable;
 pub use function::{

datafusion/physical-expr/src/planner.rs

@@ -307,10 +307,17 @@ pub fn create_physical_expr(
             input_schema,
             execution_props,
         )?),
-        Expr::GetIndexedField { expr, key } => Ok(Arc::new(GetIndexedFieldExpr::new(
-            create_physical_expr(expr, input_dfschema, input_schema, execution_props)?,
-            key.clone(),
-        ))),
+        Expr::GetIndexedField(get_indexed_field) => {
+            Ok(Arc::new(GetIndexedFieldExpr::new(
+                create_physical_expr(
+                    &get_indexed_field.expr,
+                    input_dfschema,
+                    input_schema,
+                    execution_props,
+                )?,
+                get_indexed_field.key.clone(),
+            )))
+        }
 
         Expr::ScalarFunction { fun, args } => {
             let physical_args = args

datafusion/proto/src/from_proto.rs

@@ -41,7 +41,7 @@ use datafusion_expr::{
     sha384, sha512, signum, sin, split_part, sqrt, starts_with, strpos, substr, tan,
     to_hex, to_timestamp_micros, to_timestamp_millis, to_timestamp_seconds, translate,
     trim, trunc, upper, AggregateFunction, BuiltInWindowFunction, BuiltinScalarFunction,
-    Case, Expr, GroupingSet,
+    Case, Expr, GetIndexedField, GroupingSet,
     GroupingSet::GroupingSets,
     Operator, WindowFrame, WindowFrameBound, WindowFrameUnits,
 };
@@ -800,10 +800,10 @@ pub fn parse_expr(
 
             let expr = parse_required_expr(&field.expr, registry, "expr")?;
 
-            Ok(Expr::GetIndexedField {
+            Ok(Expr::GetIndexedField(GetIndexedField {
                 expr: Box::new(expr),
                 key,
-            })
+            }))
         }
         ExprType::Column(column) => Ok(Expr::Column(column.into())),
         ExprType::Literal(literal) => {

datafusion/proto/src/to_proto.rs

@@ -831,11 +831,12 @@ impl TryFrom<&Expr> for protobuf::LogicalExprNode {
                 // see discussion in https://github.com/apache/arrow-datafusion/issues/2565
                 return Err(Error::General("Proto serialization error: Expr::ScalarSubquery(_) | Expr::InSubquery { .. } | Expr::Exists { .. } not supported".to_string()))
             }
-            Expr::GetIndexedField { key, expr } => Self {
+            Expr::GetIndexedField(get_indexed_field) =>
+                Self {
                 expr_type: Some(ExprType::GetIndexedField(Box::new(
                     protobuf::GetIndexedField {
-                        key: Some(key.try_into()?),
-                        expr: Some(Box::new(expr.as_ref().try_into()?)),
+                        key: Some((&get_indexed_field.key).try_into()?),
+                        expr: Some(Box::new(get_indexed_field.expr.as_ref().try_into()?)),
                     },
                 ))),
             },

datafusion/sql/src/planner.rs

@@ -35,8 +35,8 @@ use datafusion_expr::utils::{
     COUNT_STAR_EXPANSION,
 };
 use datafusion_expr::{
-    and, col, lit, AggregateFunction, AggregateUDF, Expr, ExprSchemable, Operator,
-    ScalarUDF, WindowFrame, WindowFrameUnits,
+    and, col, lit, AggregateFunction, AggregateUDF, Expr, ExprSchemable, GetIndexedField,
+    Operator, ScalarUDF, WindowFrame, WindowFrameUnits,
 };
 use datafusion_expr::{
     window_function::WindowFunction, BuiltinScalarFunction, TableSource,
@@ -123,10 +123,10 @@ fn plan_indexed(expr: Expr, mut keys: Vec<SQLExpr>) -> Result<Expr> {
         expr
     };
 
-    Ok(Expr::GetIndexedField {
+    Ok(Expr::GetIndexedField(GetIndexedField {
         expr: Box::new(expr),
         key: plan_key(key)?,
-    })
+    }))
 }
 
 impl<'a, S: ContextProvider> SqlToRel<'a, S> {
@@ -1834,10 +1834,10 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
                                 Err(_) => {
                                     if let Some(field) = schema.fields().iter().find(|f| f.name().eq(&relation)) {
                                         // Access to a field of a column which is a structure, example: SELECT my_struct.key
-                                        Ok(Expr::GetIndexedField {
+                                        Ok(Expr::GetIndexedField(GetIndexedField {
                                             expr: Box::new(Expr::Column(field.qualified_column())),
                                             key: ScalarValue::Utf8(Some(name)),
-                                        })
+                                        }))
                                     } else {
                                         // table.column identifier
                                         Ok(Expr::Column(Column {

datafusion/sql/src/utils.rs

@@ -21,7 +21,7 @@ use arrow::datatypes::{DataType, DECIMAL128_MAX_PRECISION, DECIMAL_DEFAULT_SCALE
 use sqlparser::ast::Ident;
 
 use datafusion_common::{DataFusionError, Result, ScalarValue};
-use datafusion_expr::expr::{Case, GroupingSet};
+use datafusion_expr::expr::{Case, GetIndexedField, GroupingSet};
 use datafusion_expr::utils::{expr_as_column_expr, find_column_exprs};
 use datafusion_expr::{Expr, LogicalPlan};
 use std::collections::HashMap;
@@ -375,10 +375,15 @@ where
             }),
             Expr::Wildcard => Ok(Expr::Wildcard),
             Expr::QualifiedWildcard { .. } => Ok(expr.clone()),
-            Expr::GetIndexedField { expr, key } => Ok(Expr::GetIndexedField {
-                expr: Box::new(clone_with_replacement(expr.as_ref(), replacement_fn)?),
-                key: key.clone(),
-            }),
+            Expr::GetIndexedField(get_indexed_field) => {
+                Ok(Expr::GetIndexedField(GetIndexedField {
+                    expr: Box::new(clone_with_replacement(
+                        get_indexed_field.expr.as_ref(),
+                        replacement_fn,
+                    )?),
+                    key: get_indexed_field.key.clone(),
+                }))
+            }
             Expr::GroupingSet(set) => match set {
                 GroupingSet::Rollup(exprs) => Ok(Expr::GroupingSet(GroupingSet::Rollup(
                     exprs