refactor(physical-expr): adopt proto ctx expr helpers in InList and Like

Replace the hand-rolled list maps and missing-required-field checks in
`InListExpr` and `LikeExpr`'s `try_to_proto`/`try_from_proto` with the
new `encode_children_expressions`, `decode_children_expressions`, and
`decode_required_expression` ctx methods.

Behavior note: `decode_required_expression` couples the presence check
with the decode, so `LikeExpr` now decodes children left-to-right rather
than validating both required fields up front. The end result is
unchanged (a missing required field still errors), but a present sibling
is decoded before a later missing field is reported; the
`try_from_proto_rejects_missing_pattern` test is updated accordingly.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: adriangb

datafusion/physical-expr/src/expressions/in_list.rs

@@ -263,17 +263,9 @@ impl InListExpr {
             }
         };
 
-        let expr = ctx.decode(node.expr.as_deref().ok_or_else(|| {
-            datafusion_common::DataFusionError::Internal(
-                "InList is missing required field 'expr'".to_string(),
-            )
-        })?)?;
-
-        let list = node
-            .list
-            .iter()
-            .map(|e| ctx.decode(e))
-            .collect::<Result<Vec<_>>>()?;
+        let expr =
+            ctx.decode_required_expression(node.expr.as_deref(), "InListExpr", "expr")?;
+        let list = ctx.decode_children_expressions(&node.list)?;
 
         Ok(Arc::new(InListExpr::try_new(
             expr,
@@ -491,11 +483,7 @@ impl PhysicalExpr for InListExpr {
             expr_type: Some(protobuf::physical_expr_node::ExprType::InList(Box::new(
                 protobuf::PhysicalInListNode {
                     expr: Some(Box::new(ctx.encode_child(&self.expr)?)),
-                    list: self
-                        .list
-                        .iter()
-                        .map(|e| ctx.encode_child(e))
-                        .collect::<Result<Vec<_>>>()?,
+                    list: ctx.encode_children_expressions(&self.list)?,
                     negated: self.negated,
                 },
             ))),
@@ -4007,7 +3995,7 @@ mod proto_tests {
         let err = InListExpr::try_from_proto(&node, &ctx).unwrap_err();
         assert!(matches!(
             err,
-            DataFusionError::Internal(msg) if msg.contains("InList is missing required field 'expr'")
+            DataFusionError::Internal(msg) if msg.contains("InListExpr is missing required field 'expr'")
         ));
     }
 

datafusion/physical-expr/src/expressions/like.rs

@@ -190,22 +190,19 @@ impl LikeExpr {
             _ => return internal_err!("PhysicalExprNode is not a LikeExpr"),
         };
 
-        let expr = like_expr.expr.as_deref().ok_or_else(|| {
-            datafusion_common::DataFusionError::Internal(
-                "LikeExpr is missing required field 'expr'".to_string(),
-            )
-        })?;
-        let pattern = like_expr.pattern.as_deref().ok_or_else(|| {
-            datafusion_common::DataFusionError::Internal(
-                "LikeExpr is missing required field 'pattern'".to_string(),
-            )
-        })?;
-
         Ok(Arc::new(LikeExpr::new(
             like_expr.negated,
             like_expr.case_insensitive,
-            ctx.decode(expr)?,
-            ctx.decode(pattern)?,
+            ctx.decode_required_expression(
+                like_expr.expr.as_deref(),
+                "LikeExpr",
+                "expr",
+            )?,
+            ctx.decode_required_expression(
+                like_expr.pattern.as_deref(),
+                "LikeExpr",
+                "pattern",
+            )?,
         )))
     }
 }
@@ -491,7 +488,9 @@ mod proto_tests {
     fn try_from_proto_rejects_missing_pattern() {
         let node = like_node(false, false, Some(Box::new(column_node("a"))), None);
         let schema = Schema::empty();
-        let decoder = UnreachableDecoder;
+        // `expr` is present, so it is decoded before the missing-`pattern`
+        // check fires; use a decoder that succeeds for that first child.
+        let decoder = StubDecoder::ok();
         let ctx = PhysicalExprDecodeCtx::new(&schema, &decoder);
         let err = LikeExpr::try_from_proto(&node, &ctx).unwrap_err();
         assert!(matches!(