@@ -281,7 +281,7 @@ The type-name conversion functions (`bigint`, `binary`, `boolean`, `date`, `deci
 | `hour` | ✅ | Native |  |
 | `last_day` | ✅ | Native |  |
 | `localtimestamp` | ✅ | — |  |
-| `make_date` | ✅ | Native |  |
+| `make_date` | ✅ | Native | Computed arguments preserve year → month → day NULL checks. Expressions fall back when shared subexpressions or a parent could change which arguments Spark evaluates. IN probes stay native for literal/column candidates and array/struct constructors of those values; other computed candidates require Spark evaluation. |
 | `make_dt_interval` | ✅ | Codegen dispatch |  |
 | `make_interval` | ✅ | Hybrid | Routes through the JVM codegen dispatcher by default; intervals outside Arrow's nanosecond range are tracked by [#5279](https://github.com/apache/datafusion-comet/issues/5279); the native path is opt-in via allowIncompatible ([details](compatibility/expressions/datetime.md)) |
 | `make_time` | ✅ | — | Spark 4.1+; requires `spark.sql.timeType.enabled=true`, which Spark leaves off by default. Runs natively; remaining TIME type work is tracked by [#4288](https://github.com/apache/datafusion-comet/issues/4288) |
 
@@ -118,7 +118,7 @@ use datafusion_comet_spark_expr::{
     coerce_to_common_type, create_case_when, create_if_expr, decimal128_add_sub_width,
     jvm_udf::JvmScalarUdfExpr, spark_in_list, ArrayInsert, AtLeastNNonNulls, Cast, CheckOverflow,
     CreateNamedStruct, DecimalRescaleCheckOverflow, FloatOperands, GetArrayStructFields,
-    GetStructField, IfExpr, ListExtract, NormalizeNaNAndZero, NormalizeNestedFloats,
+    GetStructField, IfExpr, ListExtract, MakeDateExpr, NormalizeNaNAndZero, NormalizeNestedFloats,
     NullShortCircuit, SparkCastOptions, ToJson, UnboundColumn, WideDecimalBinaryExpr,
     WideDecimalOp,
 };
@@ -2192,6 +2192,11 @@ impl PhysicalPlanner {
         } else {
             scalar_expr
         };
+        let scalar_expr = if fun_name == "make_date" {
+            Arc::new(MakeDateExpr::new(scalar_expr)) as Arc<dyn PhysicalExpr>
+        } else {
+            scalar_expr
+        };
 
         // DF53 changed some UDFs (e.g. md5) to return StringViewArray at execution
         // time (apache/datafusion#20045). Comet does not yet support view types, so
 
@@ -17,15 +17,85 @@
 
 use arrow::array::{Array, Date32Array, Int32Array};
 use arrow::compute::cast;
-use arrow::datatypes::DataType;
+use arrow::datatypes::{DataType, FieldRef, Schema};
+use arrow::record_batch::RecordBatch;
 use datafusion::common::{utils::take_function_args, DataFusionError, Result};
 use datafusion::logical_expr::{
     ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility,
 };
+use datafusion::physical_expr::PhysicalExpr;
+use std::fmt::{Display, Formatter};
 use std::sync::Arc;
 
 use crate::{conversion_funcs::ymd_to_epoch_day, SparkError};
 
+/// Skips the entire date expression on empty input, before any argument can raise an error.
+/// `inner` retains the planner's argument evaluation, including NULL short-circuiting when enabled.
+#[derive(Debug, Eq, Hash)]
+pub struct MakeDateExpr {
+    inner: Arc<dyn PhysicalExpr>,
+}
+
+impl MakeDateExpr {
+    pub fn new(inner: Arc<dyn PhysicalExpr>) -> Self {
+        Self { inner }
+    }
+}
+
+impl PartialEq for MakeDateExpr {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner.eq(&other.inner)
+    }
+}
+
+impl Display for MakeDateExpr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.inner, f)
+    }
+}
+
+impl PhysicalExpr for MakeDateExpr {
+    fn data_type(&self, input_schema: &Schema) -> Result<DataType> {
+        self.inner.data_type(input_schema)
+    }
+
+    fn nullable(&self, input_schema: &Schema) -> Result<bool> {
+        self.inner.nullable(input_schema)
+    }
+
+    fn return_field(&self, input_schema: &Schema) -> Result<FieldRef> {
+        self.inner.return_field(input_schema)
+    }
+
+    fn evaluate(&self, batch: &RecordBatch) -> Result<ColumnarValue> {
+        if batch.num_rows() == 0 {
+            return Ok(ColumnarValue::Array(Arc::new(Date32Array::new_null(0))));
+        }
+        self.inner.evaluate(batch)
+    }
+
+    fn children(&self) -> Vec<&Arc<dyn PhysicalExpr>> {
+        self.inner.children()
+    }
+
+    fn with_new_children(
+        self: Arc<Self>,
+        children: Vec<Arc<dyn PhysicalExpr>>,
+    ) -> Result<Arc<dyn PhysicalExpr>> {
+        Ok(Arc::new(Self::new(
+            Arc::clone(&self.inner).with_new_children(children)?,
+        )))
+    }
+
+    fn fmt_sql(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.inner.fmt_sql(f)
+    }
+
+    fn is_volatile_node(&self) -> bool {
+        self.inner.is_volatile_node()
+    }
+}
+
 /// Spark-compatible make_date function.
 /// Creates a date from year, month, and day columns.
 /// For an invalid `(year, month, day)` triple Spark returns NULL when `spark.sql.ansi.enabled` is
@@ -192,6 +262,92 @@ impl ScalarUDFImpl for SparkMakeDate {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::{Cast, EvalMode, NullShortCircuit, SparkCastOptions};
+    use arrow::datatypes::{Field, Schema};
+    use arrow::record_batch::{RecordBatch, RecordBatchOptions};
+    use datafusion::common::ScalarValue;
+    use datafusion::config::ConfigOptions;
+    use datafusion::logical_expr::ScalarUDF;
+    use datafusion::physical_expr::expressions::{col, lit, Literal};
+    use datafusion::physical_expr::{PhysicalExpr, ScalarFunctionExpr};
+
+    #[test]
+    fn scalar_arguments_do_not_validate_dates_on_empty_batches() {
+        let expression = MakeDateExpr::new(Arc::new(ScalarFunctionExpr::new(
+            "make_date",
+            Arc::new(ScalarUDF::new_from_impl(SparkMakeDate::new(true))),
+            [2024, 13, 1]
+                .into_iter()
+                .map(|value| {
+                    Arc::new(Literal::new(ScalarValue::Int32(Some(value)))) as Arc<dyn PhysicalExpr>
+                })
+                .collect(),
+            Arc::new(Field::new("make_date", DataType::Date32, true)),
+            Arc::new(ConfigOptions::default()),
+        )));
+        let batch = |number_rows| {
+            RecordBatch::try_new_with_options(
+                Arc::new(Schema::empty()),
+                vec![],
+                &RecordBatchOptions::new().with_row_count(Some(number_rows)),
+            )
+            .unwrap()
+        };
+        let result = expression
+            .evaluate(&batch(0))
+            .unwrap()
+            .into_array(0)
+            .unwrap();
+        assert_eq!(result.data_type(), &DataType::Date32);
+        assert!(result.is_empty());
+        assert!(expression.evaluate(&batch(1)).is_err());
+    }
+
+    #[test]
+    fn empty_batches_do_not_evaluate_make_date_arguments() {
+        let schema = Arc::new(Schema::new(vec![Field::new("y", DataType::Int32, true)]));
+        let batch = RecordBatch::try_new(
+            Arc::clone(&schema),
+            vec![Arc::new(Int32Array::from(vec![2024]))],
+        )
+        .unwrap();
+        let bad_cast: Arc<dyn PhysicalExpr> = Arc::new(Cast::new(
+            lit("bad"),
+            DataType::Int32,
+            SparkCastOptions::new_without_timezone(EvalMode::Ansi),
+            None,
+            None,
+        ));
+        // Cover the first argument, where NullShortCircuit elides its wrapper, as well as
+        // later arguments. The empty-input check is also required without NULL short-circuiting.
+        for argument in 0..3 {
+            for short_circuit in [false, true] {
+                let mut args = vec![col("y", &schema).unwrap(), lit(1i32), lit(1i32)];
+                args[argument] = Arc::clone(&bad_cast);
+                let inner: Arc<dyn PhysicalExpr> = Arc::new(ScalarFunctionExpr::new(
+                    "make_date",
+                    Arc::new(ScalarUDF::new_from_impl(SparkMakeDate::new(true))),
+                    args,
+                    Arc::new(Field::new("make_date", DataType::Date32, true)),
+                    Arc::new(ConfigOptions::default()),
+                ));
+                let inner = if short_circuit {
+                    NullShortCircuit::wrap(inner, &schema).unwrap()
+                } else {
+                    inner
+                };
+                let expression = MakeDateExpr::new(inner);
+                let ColumnarValue::Array(result) = expression.evaluate(&batch.slice(0, 0)).unwrap()
+                else {
+                    panic!("make_date must return an empty array for an empty batch");
+                };
+                assert_eq!(result.data_type(), &DataType::Date32);
+                assert!(result.is_empty());
+                let error = expression.evaluate(&batch).unwrap_err().to_string();
+                assert!(error.contains("CAST_INVALID_INPUT"), "{error}");
+            }
+        }
+    }
 
     #[test]
     fn test_make_date_valid() {
 
@@ -41,7 +41,7 @@ pub use extract_date_part::SparkHour;
 pub use extract_date_part::SparkMinute;
 pub use extract_date_part::SparkSecond;
 pub use hours::SparkHoursTransform;
-pub use make_date::SparkMakeDate;
+pub use make_date::{MakeDateExpr, SparkMakeDate};
 pub use make_interval::SparkMakeInterval;
 pub use make_time::SparkMakeTime;
 pub use next_day::SparkNextDay;
 
@@ -87,10 +87,11 @@ pub use comet_scalar_funcs::{
 };
 pub use csv_funcs::*;
 pub use datetime_funcs::{
-    spark_day_name, spark_month_name, spark_seconds_of_time, spark_to_time, SparkDateDiff,
-    SparkDateFromUnixDate, SparkDateTrunc, SparkDayOfWeek, SparkHour, SparkHoursTransform,
-    SparkMakeDate, SparkMakeInterval, SparkMakeTime, SparkMinute, SparkNextDay, SparkSecond,
-    SparkSecondsToTimestamp, SparkUnixTimestamp, SparkWeekDay, TimestampTruncExpr,
+    spark_day_name, spark_month_name, spark_seconds_of_time, spark_to_time, MakeDateExpr,
+    SparkDateDiff, SparkDateFromUnixDate, SparkDateTrunc, SparkDayOfWeek, SparkHour,
+    SparkHoursTransform, SparkMakeDate, SparkMakeInterval, SparkMakeTime, SparkMinute,
+    SparkNextDay, SparkSecond, SparkSecondsToTimestamp, SparkUnixTimestamp, SparkWeekDay,
+    TimestampTruncExpr,
 };
 pub use error::{decimal_overflow_error, SparkError, SparkErrorWithContext, SparkResult};
 pub use hash_funcs::*;
 
@@ -938,19 +938,25 @@ object QueryPlanSerde extends Logging with CometExprShim with CometTypeShim {
       inputs: Seq[Attribute],
       binding: Boolean = true): Option[Expr] =
     CometExplainInfo.withExpressionFallbackReasonScope {
-      val newExpr = DecimalPrecision.promote(expr)
-      val result = exprToProtoInternal(newExpr, inputs, binding)
-      if (!(newExpr eq expr)) {
-        // `promote` rebuilt the tree, so the tags landed on copies that the operator does not hold.
-        // Lift them onto `expr` so the roll-ups in `CometExecRule`, which walk the operator's own
-        // expressions, still see them. Skipped in the common case where `promote` returned the same
-        // tree and there is nothing to lift.
-        liftCoverageTags(newExpr, expr)
-        if (result.isEmpty) {
-          liftFallbackReasons(newExpr, expr)
-        }
+      CometMakeDate.unsupportedParentReason(expr) match {
+        case Some(reason) =>
+          withFallbackReason(expr, reason)
+          None
+        case None =>
+          val newExpr = DecimalPrecision.promote(expr)
+          val result = exprToProtoInternal(newExpr, inputs, binding)
+          if (!(newExpr eq expr)) {
+            // `promote` rebuilt the tree, so the tags landed on copies that the operator does
+            // not hold. Lift them onto `expr` so the roll-ups in `CometExecRule`, which walk
+            // the operator's own expressions, still see them. Skipped in the common case where
+            // `promote` returned the same tree and there is nothing to lift.
+            liftCoverageTags(newExpr, expr)
+            if (result.isEmpty) {
+              liftFallbackReasons(newExpr, expr)
+            }
+          }
+          result
       }
-      result
     }
 
   /**
 
@@ -21,7 +21,7 @@ package org.apache.comet.serde
 
 import java.util.Locale
 
-import org.apache.spark.sql.catalyst.expressions.{AddMonths, Attribute, Cast, ConvertTimezone, DateAdd, DateDiff, DateFormatClass, DateFromUnixDate, DateSub, DayOfMonth, DayOfWeek, DayOfYear, Days, DivideDTInterval, Expression, FromUTCTimestamp, GetDateField, GetTimestamp, Hour, Hours, LastDay, Literal, MakeDate, MakeDTInterval, MakeInterval, MakeTimestamp, MakeYMInterval, MicrosToTimestamp, MillisToTimestamp, Minute, Month, MonthsBetween, MultiplyDTInterval, MultiplyYMInterval, NextDay, PreciseTimestampConversion, Quarter, Second, SecondsToTimestamp, TimestampAdd, TimestampDiff, ToUnixTimestamp, ToUTCTimestamp, TruncDate, TruncTimestamp, UnixDate, UnixMicros, UnixMillis, UnixSeconds, UnixTimestamp, WeekDay, WeekOfYear, Year}
+import org.apache.spark.sql.catalyst.expressions.{AddMonths, Attribute, BinaryComparison, CaseWhen, Cast, Coalesce, ConvertTimezone, CreateArray, CreateNamedStruct, DateAdd, DateDiff, DateFormatClass, DateFromUnixDate, DateSub, DayOfMonth, DayOfWeek, DayOfYear, Days, DivideDTInterval, EqualNullSafe, Expression, FromUTCTimestamp, GetDateField, GetTimestamp, Hour, Hours, If, In, InSet, LastDay, LeafExpression, Literal, MakeDate, MakeDTInterval, MakeInterval, MakeTimestamp, MakeYMInterval, MicrosToTimestamp, MillisToTimestamp, Minute, Month, MonthsBetween, MultiplyDTInterval, MultiplyYMInterval, NextDay, PreciseTimestampConversion, Quarter, Second, SecondsToTimestamp, SortOrder, TimestampAdd, TimestampDiff, ToUnixTimestamp, ToUTCTimestamp, TruncDate, TruncTimestamp, UnixDate, UnixMicros, UnixMillis, UnixSeconds, UnixTimestamp, WeekDay, WeekOfYear, Year}
 import org.apache.spark.sql.types.{CalendarIntervalType, DataType, DateType, DoubleType, FloatType, IntegerType, LongType, StringType, TimestampNTZType, TimestampType}
 import org.apache.spark.unsafe.types.UTF8String
 
@@ -436,6 +436,85 @@ object CometNextDay extends CometExpressionSerde[NextDay] with CodegenDispatchFa
 
 object CometMakeDate extends CometExpressionSerde[MakeDate] {
 
+  private val sharedArgumentReason =
+    "make_date requires Spark evaluation when a computed argument after a nullable " +
+      "argument cannot preserve Spark's shared-subexpression evaluation."
+
+  override def getUnsupportedReasons(): Seq[String] = Seq(sharedArgumentReason)
+
+  override def getSupportLevel(expr: MakeDate): SupportLevel = {
+    val firstNullable = expr.children.indexWhere(_.nullable)
+    val hasComputedMaskedArgument = firstNullable >= 0 &&
+      expr.children.drop(firstNullable + 1).exists(!_.isInstanceOf[LeafExpression])
+    if (hasComputedMaskedArgument && !canShortCircuitNulls(expr)) {
+      Unsupported(Some(sharedArgumentReason))
+    } else {
+      Compatible()
+    }
+  }
+
+  // Native IN evaluates dynamic candidates for the whole batch. Only these constructors and
+  // leaves are safe on rows where Spark skips a candidate after a match or a NULL probe.
+  private def canEvaluateInCandidateEagerly(expr: Expression): Boolean = expr match {
+    case _: Literal | _: Attribute => true
+    case _: CreateArray | _: CreateNamedStruct =>
+      expr.children.forall(canEvaluateInCandidateEagerly)
+    case _ => false
+  }
+
+  /** A native parent must preserve Spark's evaluation of a date and its sibling expressions. */
+  private[serde] def unsupportedParentReason(expr: Expression): Option[String] = {
+    var pending: List[(Expression, Option[String])] = (expr, None) :: Nil
+    while (pending.nonEmpty) {
+      val (current, parent) = pending.head
+      pending = pending.tail
+      if (current.isInstanceOf[MakeDate] && parent.isDefined) {
+        return Some(s"make_date requires Spark evaluation under ${parent.get}")
+      }
+      def pushChildren(mask: Option[String]): Unit = {
+        current.children.reverseIterator.foreach(child => pending = (child, mask) :: pending)
+      }
+      if (parent.isDefined) {
+        pushChildren(parent)
+      } else {
+        current match {
+          // These native expressions already select the rows passed to their children.
+          case _: If | _: CaseWhen | _: MakeDate => pushChildren(None)
+          // COALESCE lowers to CASE and evaluates an earlier child again in its result branch.
+          case coalesce: Coalesce if coalesce.deterministic => pushChildren(None)
+          // These parents evaluate every child in Spark, including NULL values.
+          case _: EqualNullSafe | _: CreateArray | _: CreateNamedStruct =>
+            pushChildren(None)
+          // These parents evaluate left first and skip right only when left is NULL.
+          case _: BinaryComparison | _: DateAdd | _: DateSub | _: DateDiff | _: DateFormatClass =>
+            val left = current.children.head
+            val right = current.children(1)
+            val rightMask = if (left.nullable) Some(current.nodeName) else None
+            pending = (left, None) :: (right, rightMask) :: pending
+          case _: SortOrder => pushChildren(Some(current.nodeName))
+          // Empty membership can skip its sole operand in Spark.
+          case in: In if in.list.isEmpty => pushChildren(Some(current.nodeName))
+          case inSet: InSet if inSet.hset.isEmpty => pushChildren(Some(current.nodeName))
+          // Nonempty IN always evaluates its probe, but may skip candidates on individual rows.
+          case in: In =>
+            in.list.reverseIterator.foreach { child =>
+              pending = (child, Some(in.nodeName)) :: pending
+            }
+            val probeParent = if (in.list.forall(canEvaluateInCandidateEagerly)) {
+              None
+            } else {
+              Some("In with computed candidates")
+            }
+            pending = (in.value, probeParent) :: pending
+          case _ if current.children.size <= 1 => pushChildren(None)
+          // Other native multi-child expressions may evaluate operands that Spark skips.
+          case _ => pushChildren(Some(current.nodeName))
+        }
+      }
+    }
+    None
+  }
+
   /**
    * `failOnError` mirrors `spark.sql.ansi.enabled`: under ANSI, Spark throws on an invalid
    * `(year, month, day)` triple rather than returning NULL. The resolved flag is passed to native
@@ -449,7 +528,7 @@ object CometMakeDate extends CometExpressionSerde[MakeDate] {
       DateType,
       expr.failOnError,
       childExpr: _*)
-    optExpr
+    withNullShortCircuit(expr, optExpr)
   }
 }