Convert list_length_max to new infrastructure

Uses the eager binary function infrastructure to implement the
list_length_max function. This should be a good playground, also because
the function isn't enabled.

Signed-off-by: Moritz Hoffmann <antiguru@gmail.com>

Author: antiguru

src/expr/src/scalar/func.rs

@@ -2664,7 +2664,7 @@ pub enum BinaryFunc {
     TrimLeading(TrimLeading),
     TrimTrailing(TrimTrailing),
     EncodedBytesCharLength(EncodedBytesCharLength),
-    ListLengthMax { max_layer: usize },
+    ListLengthMax(ListLengthMax),
     ArrayContains(ArrayContains),
     ArrayContainsArray { rev: bool },
     ArrayLength(ArrayLength),
@@ -2937,7 +2937,7 @@ impl BinaryFunc {
             BinaryFunc::EncodedBytesCharLength(s) => {
                 return s.eval(datums, temp_storage, a_expr, b_expr);
             }
-            // BinaryFunc::ListLengthMax { max_layer }(s) => return s.eval(datums, temp_storage, a_expr, b_expr),
+            BinaryFunc::ListLengthMax(s) => return s.eval(datums, temp_storage, a_expr, b_expr),
             BinaryFunc::ArrayLength(s) => return s.eval(datums, temp_storage, a_expr, b_expr),
             BinaryFunc::ArrayContains(s) => return s.eval(datums, temp_storage, a_expr, b_expr),
             // BinaryFunc::ArrayContainsArray { rev: false } => Ok(array_contains_array(a, b)),
@@ -3037,7 +3037,6 @@ impl BinaryFunc {
             BinaryFunc::JsonbGetStringStringify => Ok(jsonb_get_string(a, b, temp_storage, true)),
             BinaryFunc::JsonbGetPath => Ok(jsonb_get_path(a, b, temp_storage, false)),
             BinaryFunc::JsonbGetPathStringify => Ok(jsonb_get_path(a, b, temp_storage, true)),
-            BinaryFunc::ListLengthMax { max_layer } => list_length_max(a, b, *max_layer),
             BinaryFunc::ArrayContainsArray { rev: false } => Ok(array_contains_array(a, b)),
             BinaryFunc::ArrayContainsArray { rev: true } => Ok(array_contains_array(b, a)),
             BinaryFunc::ListContainsList { rev: false } => Ok(list_contains_list(a, b)),
@@ -3258,7 +3257,7 @@ impl BinaryFunc {
             ArrayLower(s) => s.output_type(input1_type, input2_type),
             ArrayUpper(s) => s.output_type(input1_type, input2_type),
 
-            ListLengthMax { .. } => SqlScalarType::Int32.nullable(true),
+            ListLengthMax(s) => s.output_type(input1_type, input2_type),
 
             ArrayArrayConcat(s) => s.output_type(input1_type, input2_type),
             ArrayRemove(s) => s.output_type(input1_type, input2_type),
@@ -3432,7 +3431,7 @@ impl BinaryFunc {
             BinaryFunc::LikeEscape(s) => s.propagates_nulls(),
             BinaryFunc::ListContainsList { .. } => true,
             BinaryFunc::ListElementConcat(s) => s.propagates_nulls(),
-            BinaryFunc::ListLengthMax { .. } => true,
+            BinaryFunc::ListLengthMax(s) => s.propagates_nulls(),
             BinaryFunc::ListListConcat(s) => s.propagates_nulls(),
             BinaryFunc::ListRemove(s) => s.propagates_nulls(),
             BinaryFunc::LogNumeric(s) => s.propagates_nulls(),
@@ -3724,7 +3723,7 @@ impl BinaryFunc {
             JsonbGetPathStringify => true,
             JsonbGetString => true,
             JsonbGetStringStringify => true,
-            ListLengthMax { .. } => true,
+            ListLengthMax(s) => s.introduces_nulls(),
             MapGetValue(s) => s.introduces_nulls(),
         }
     }
@@ -3901,7 +3900,7 @@ impl BinaryFunc {
             GetByte(s) => s.is_infix_op(),
             Left(s) => s.is_infix_op(),
             LikeEscape(s) => s.is_infix_op(),
-            ListLengthMax { .. } => false,
+            ListLengthMax(s) => s.is_infix_op(),
             ListRemove(s) => s.is_infix_op(),
             LogNumeric(s) => s.is_infix_op(),
             MzAclItemContainsPrivilege(s) => s.is_infix_op(),
@@ -4045,7 +4044,7 @@ impl BinaryFunc {
             BinaryFunc::LikeEscape(s) => s.negate(),
             BinaryFunc::ListContainsList { .. } => None,
             BinaryFunc::ListElementConcat(s) => s.negate(),
-            BinaryFunc::ListLengthMax { .. } => None,
+            BinaryFunc::ListLengthMax(s) => s.negate(),
             BinaryFunc::ListListConcat(s) => s.negate(),
             BinaryFunc::ListRemove(s) => s.negate(),
             BinaryFunc::LogNumeric(s) => s.negate(),
@@ -4310,7 +4309,7 @@ impl BinaryFunc {
             BinaryFunc::RepeatString => true,
             BinaryFunc::Normalize => true,
             BinaryFunc::EncodedBytesCharLength(s) => s.could_error(),
-            BinaryFunc::ListLengthMax { .. } => true,
+            BinaryFunc::ListLengthMax(s) => s.could_error(),
             BinaryFunc::ArrayLength(s) => s.could_error(),
             BinaryFunc::ArrayRemove(s) => s.could_error(),
             BinaryFunc::ArrayUpper(s) => s.could_error(),
@@ -4510,7 +4509,7 @@ impl BinaryFunc {
             BinaryFunc::TrimLeading(s) => s.is_monotone(),
             BinaryFunc::TrimTrailing(s) => s.is_monotone(),
             BinaryFunc::EncodedBytesCharLength(s) => s.is_monotone(),
-            BinaryFunc::ListLengthMax { .. } => (false, false),
+            BinaryFunc::ListLengthMax(s) => s.is_monotone(),
             BinaryFunc::ArrayContains(s) => s.is_monotone(),
             BinaryFunc::ArrayContainsArray { .. } => (false, false),
             BinaryFunc::ArrayLength(s) => s.is_monotone(),
@@ -4718,7 +4717,7 @@ impl fmt::Display for BinaryFunc {
             BinaryFunc::TrimLeading(s) => s.fmt(f),
             BinaryFunc::TrimTrailing(s) => s.fmt(f),
             BinaryFunc::EncodedBytesCharLength(s) => s.fmt(f),
-            BinaryFunc::ListLengthMax { .. } => f.write_str("list_length_max"),
+            BinaryFunc::ListLengthMax(s) => s.fmt(f),
             BinaryFunc::ArrayContains(s) => s.fmt(f),
             BinaryFunc::ArrayContainsArray { rev } => f.write_str(if *rev { "<@" } else { "@>" }),
             BinaryFunc::ArrayLength(s) => s.fmt(f),
@@ -5226,48 +5225,6 @@ fn array_upper<'a>(a: Array<'a>, i: i64) -> Result<Option<i32>, EvalError> {
         .transpose()
 }
 
-// TODO(benesch): remove potentially dangerous usage of `as`.
-#[allow(clippy::as_conversions)]
-fn list_length_max<'a>(
-    a: Datum<'a>,
-    b: Datum<'a>,
-    max_layer: usize,
-) -> Result<Datum<'a>, EvalError> {
-    fn max_len_on_layer<'a>(d: Datum<'a>, on_layer: i64) -> Option<usize> {
-        match d {
-            Datum::List(i) => {
-                let mut i = i.iter();
-                if on_layer > 1 {
-                    let mut max_len = None;
-                    while let Some(Datum::List(i)) = i.next() {
-                        max_len =
-                            std::cmp::max(max_len_on_layer(Datum::List(i), on_layer - 1), max_len);
-                    }
-                    max_len
-                } else {
-                    Some(i.count())
-                }
-            }
-            Datum::Null => None,
-            _ => unreachable!(),
-        }
-    }
-
-    let b = b.unwrap_int64();
-
-    if b as usize > max_layer || b < 1 {
-        Err(EvalError::InvalidLayer { max_layer, val: b })
-    } else {
-        match max_len_on_layer(a, b) {
-            Some(l) => match l.try_into() {
-                Ok(c) => Ok(Datum::Int32(c)),
-                Err(_) => Err(EvalError::Int32OutOfRange(l.to_string().into())),
-            },
-            None => Ok(Datum::Null),
-        }
-    }
-}
-
 #[sqlfunc(
     is_infix_op = true,
     sqlname = "array_contains",

src/expr/src/scalar/func/binary.rs

@@ -291,7 +291,7 @@ mod derive {
         LikeEscape,
         // ListContainsList
         ListElementConcat,
-        // ListLengthMax
+        ListLengthMax,
         ListListConcat,
         ListRemove,
         LogNumeric(LogBaseNumeric),

src/expr/src/scalar/func/impls/list.rs

@@ -10,7 +10,7 @@
 use std::fmt;
 
 use mz_lowertest::MzReflect;
-use mz_repr::{Datum, Row, RowArena, SqlColumnType, SqlScalarType};
+use mz_repr::{Datum, DatumList, Row, RowArena, SqlColumnType, SqlScalarType};
 use serde::{Deserialize, Serialize};
 
 use crate::scalar::func::{LazyUnaryFunc, stringify_datum};
@@ -249,3 +249,74 @@ impl fmt::Display for ListLength {
         f.write_str("list_length")
     }
 }
+
+/// The `list_length_max` implementation.
+#[derive(
+    Ord,
+    PartialOrd,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    serde::Serialize,
+    serde::Deserialize,
+    Hash,
+    mz_lowertest::MzReflect,
+)]
+pub struct ListLengthMax {
+    /// Maximal allowed layer to query.
+    pub max_layer: usize,
+}
+impl<'a> crate::func::binary::EagerBinaryFunc<'a> for ListLengthMax {
+    type Input1 = DatumList<'a>;
+    type Input2 = i64;
+    type Output = Result<Option<i32>, EvalError>;
+    // TODO(benesch): remove potentially dangerous usage of `as`.
+    #[allow(clippy::as_conversions)]
+    fn call(&self, a: Self::Input1, b: Self::Input2, _: &'a RowArena) -> Self::Output {
+        fn max_len_on_layer<'a>(i: DatumList<'a>, on_layer: i64) -> Option<usize> {
+            let mut i = i.iter();
+            if on_layer > 1 {
+                let mut max_len = None;
+                while let Some(Datum::List(i)) = i.next() {
+                    max_len = std::cmp::max(max_len_on_layer(i, on_layer - 1), max_len);
+                }
+                max_len
+            } else {
+                Some(i.count())
+            }
+        }
+        if b as usize > self.max_layer || b < 1 {
+            Err(EvalError::InvalidLayer {
+                max_layer: self.max_layer,
+                val: b,
+            })
+        } else {
+            match max_len_on_layer(a, b) {
+                Some(l) => match l.try_into() {
+                    Ok(c) => Ok(Some(c)),
+                    Err(_) => Err(EvalError::Int32OutOfRange(l.to_string().into())),
+                },
+                None => Ok(None),
+            }
+        }
+    }
+    fn output_type(
+        &self,
+        input_type_a: SqlColumnType,
+        input_type_b: SqlColumnType,
+    ) -> SqlColumnType {
+        use mz_repr::AsColumnType;
+        let output = Self::Output::as_column_type();
+        let propagates_nulls = crate::func::binary::EagerBinaryFunc::propagates_nulls(self);
+        let nullable = output.nullable;
+        output.nullable(
+            nullable || (propagates_nulls && (input_type_a.nullable || input_type_b.nullable)),
+        )
+    }
+}
+impl fmt::Display for ListLengthMax {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("list_length_max")
+    }
+}

src/sql/src/func.rs

@@ -3753,7 +3753,7 @@ pub static MZ_CATALOG_BUILTINS: LazyLock<BTreeMap<&'static str, Func>> = LazyLoc
             vec![ListAny, Plain(SqlScalarType::Int64)] => Operation::binary(|ecx, lhs, rhs| {
                 ecx.require_feature_flag(&crate::session::vars::ENABLE_LIST_LENGTH_MAX)?;
                 let max_layer = ecx.scalar_type(&lhs).unwrap_list_n_layers();
-                Ok(lhs.call_binary(rhs, BinaryFunc::ListLengthMax { max_layer }))
+                Ok(lhs.call_binary(rhs, BinaryFunc::from(func::ListLengthMax { max_layer })))
             }) => Int32, oid::FUNC_LIST_LENGTH_MAX_OID;
         },
         "list_prepend" => Scalar {