Update snapshots

Signed-off-by: Moritz Hoffmann <[email protected]>

Author: antiguru

src/expr/src/scalar/snapshots/mz_expr__scalar__func__age_timestamp.snap

@@ -1,6 +1,6 @@
 ---
 source: src/expr/src/scalar/func.rs
-expression: "#[sqlfunc(\n    is_monotone = (true, true),\n    output_type = Interval,\n    is_infix_op = false,\n    sqlname = \"age\",\n    propagates_nulls = true\n)]\nfn age_timestamp<'a>(a: Datum<'a>, b: Datum<'a>) -> Result<Datum<'a>, EvalError> {\n    let a_ts = a.unwrap_timestamp();\n    let b_ts = b.unwrap_timestamp();\n    let age = a_ts.age(&b_ts)?;\n    Ok(Datum::from(age))\n}\n"
+expression: "#[sqlfunc(\n    is_monotone = \"(true, true)\",\n    output_type = \"Interval\",\n    sqlname = \"age\",\n    propagates_nulls = true\n)]\nfn age_timestamp<'a>(a: Datum<'a>, b: Datum<'a>) -> Result<Datum<'a>, EvalError> {\n    let a_ts = a.unwrap_timestamp();\n    let b_ts = b.unwrap_timestamp();\n    let age = a_ts.age(&b_ts)?;\n    Ok(Datum::from(age))\n}\n"
 ---
 #[derive(
     proptest_derive::Arbitrary,
@@ -49,9 +49,6 @@ impl<'a> crate::func::binary::EagerBinaryFunc<'a> for AgeTimestamp {
     fn introduces_nulls(&self) -> bool {
         <Interval as ::mz_repr::DatumType<'_, ()>>::nullable()
     }
-    fn is_infix_op(&self) -> bool {
-        false
-    }
     fn is_monotone(&self) -> (bool, bool) {
         (true, true)
     }

src/expr/src/scalar/snapshots/mz_expr__scalar__func__age_timestamptz.snap

@@ -1,6 +1,6 @@
 ---
 source: src/expr/src/scalar/func.rs
-expression: "#[sqlfunc(\n    is_monotone = (true, true),\n    output_type = Interval,\n    is_infix_op = false,\n    sqlname = \"age\",\n    propagates_nulls = true\n)]\nfn age_timestamptz<'a>(a: Datum<'a>, b: Datum<'a>) -> Result<Datum<'a>, EvalError> {\n    let a_ts = a.unwrap_timestamptz();\n    let b_ts = b.unwrap_timestamptz();\n    let age = a_ts.age(&b_ts)?;\n    Ok(Datum::from(age))\n}\n"
+expression: "#[sqlfunc(\n    is_monotone = \"(true, true)\",\n    output_type = \"Interval\",\n    sqlname = \"age\",\n    propagates_nulls = true\n)]\nfn age_timestamptz<'a>(a: Datum<'a>, b: Datum<'a>) -> Result<Datum<'a>, EvalError> {\n    let a_ts = a.unwrap_timestamptz();\n    let b_ts = b.unwrap_timestamptz();\n    let age = a_ts.age(&b_ts)?;\n    Ok(Datum::from(age))\n}\n"
 ---
 #[derive(
     proptest_derive::Arbitrary,
@@ -49,9 +49,6 @@ impl<'a> crate::func::binary::EagerBinaryFunc<'a> for AgeTimestamptz {
     fn introduces_nulls(&self) -> bool {
         <Interval as ::mz_repr::DatumType<'_, ()>>::nullable()
     }
-    fn is_infix_op(&self) -> bool {
-        false
-    }
     fn is_monotone(&self) -> (bool, bool) {
         (true, true)
     }

src/expr/src/scalar/snapshots/mz_expr__scalar__func__array_array_concat.snap

@@ -0,0 +1,132 @@
+---
+source: src/expr/src/scalar/func.rs
+expression: "#[sqlfunc(\n    output_type_expr = \"input_type_a.scalar_type.without_modifiers().nullable(true)\",\n    is_infix_op = true,\n    sqlname = \"||\",\n    propagates_nulls = false,\n    introduces_nulls = false\n)]\nfn array_array_concat<'a>(\n    a: Datum<'a>,\n    b: Datum<'a>,\n    temp_storage: &'a RowArena,\n) -> Result<Datum<'a>, EvalError> {\n    if a.is_null() {\n        return Ok(b);\n    } else if b.is_null() {\n        return Ok(a);\n    }\n    let a_array = a.unwrap_array();\n    let b_array = b.unwrap_array();\n    let a_dims: Vec<ArrayDimension> = a_array.dims().into_iter().collect();\n    let b_dims: Vec<ArrayDimension> = b_array.dims().into_iter().collect();\n    let a_ndims = a_dims.len();\n    let b_ndims = b_dims.len();\n    if a_ndims == 0 {\n        return Ok(b);\n    } else if b_ndims == 0 {\n        return Ok(a);\n    }\n    #[allow(clippy::as_conversions)]\n    if (a_ndims as isize - b_ndims as isize).abs() > 1 {\n        return Err(EvalError::IncompatibleArrayDimensions {\n            dims: Some((a_ndims, b_ndims)),\n        });\n    }\n    let mut dims;\n    match a_ndims.cmp(&b_ndims) {\n        Ordering::Equal => {\n            if &a_dims[1..] != &b_dims[1..] {\n                return Err(EvalError::IncompatibleArrayDimensions {\n                    dims: None,\n                });\n            }\n            dims = vec![\n                ArrayDimension { lower_bound : a_dims[0].lower_bound, length : a_dims[0]\n                .length + b_dims[0].length, }\n            ];\n            dims.extend(&a_dims[1..]);\n        }\n        Ordering::Less => {\n            if &a_dims[..] != &b_dims[1..] {\n                return Err(EvalError::IncompatibleArrayDimensions {\n                    dims: None,\n                });\n            }\n            dims = vec![\n                ArrayDimension { lower_bound : b_dims[0].lower_bound, length : b_dims[0]\n                .length + 1, }\n            ];\n            dims.extend(a_dims);\n        }\n        Ordering::Greater => {\n            if &a_dims[1..] != &b_dims[..] {\n                return Err(EvalError::IncompatibleArrayDimensions {\n                    dims: None,\n                });\n            }\n            dims = vec![\n                ArrayDimension { lower_bound : a_dims[0].lower_bound, length : a_dims[0]\n                .length + 1, }\n            ];\n            dims.extend(b_dims);\n        }\n    }\n    let elems = a_array.elements().iter().chain(b_array.elements().iter());\n    Ok(temp_storage.try_make_datum(|packer| packer.try_push_array(&dims, elems))?)\n}\n"
+---
+#[derive(
+    proptest_derive::Arbitrary,
+    Ord,
+    PartialOrd,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    serde::Serialize,
+    serde::Deserialize,
+    Hash,
+    mz_lowertest::MzReflect
+)]
+pub struct ArrayArrayConcat;
+impl<'a> crate::func::binary::EagerBinaryFunc<'a> for ArrayArrayConcat {
+    type Input1 = Datum<'a>;
+    type Input2 = Datum<'a>;
+    type Output = Result<Datum<'a>, EvalError>;
+    fn call(
+        &self,
+        a: Self::Input1,
+        b: Self::Input2,
+        temp_storage: &'a mz_repr::RowArena,
+    ) -> Self::Output {
+        array_array_concat(a, b, temp_storage)
+    }
+    fn output_type(
+        &self,
+        input_type_a: mz_repr::ColumnType,
+        input_type_b: mz_repr::ColumnType,
+    ) -> mz_repr::ColumnType {
+        use mz_repr::AsColumnType;
+        let output = input_type_a.scalar_type.without_modifiers().nullable(true);
+        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)),
+            )
+    }
+    fn introduces_nulls(&self) -> bool {
+        false
+    }
+    fn is_infix_op(&self) -> bool {
+        true
+    }
+    fn propagates_nulls(&self) -> bool {
+        false
+    }
+}
+impl std::fmt::Display for ArrayArrayConcat {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.write_str("||")
+    }
+}
+fn array_array_concat<'a>(
+    a: Datum<'a>,
+    b: Datum<'a>,
+    temp_storage: &'a RowArena,
+) -> Result<Datum<'a>, EvalError> {
+    if a.is_null() {
+        return Ok(b);
+    } else if b.is_null() {
+        return Ok(a);
+    }
+    let a_array = a.unwrap_array();
+    let b_array = b.unwrap_array();
+    let a_dims: Vec<ArrayDimension> = a_array.dims().into_iter().collect();
+    let b_dims: Vec<ArrayDimension> = b_array.dims().into_iter().collect();
+    let a_ndims = a_dims.len();
+    let b_ndims = b_dims.len();
+    if a_ndims == 0 {
+        return Ok(b);
+    } else if b_ndims == 0 {
+        return Ok(a);
+    }
+    #[allow(clippy::as_conversions)]
+    if (a_ndims as isize - b_ndims as isize).abs() > 1 {
+        return Err(EvalError::IncompatibleArrayDimensions {
+            dims: Some((a_ndims, b_ndims)),
+        });
+    }
+    let mut dims;
+    match a_ndims.cmp(&b_ndims) {
+        Ordering::Equal => {
+            if &a_dims[1..] != &b_dims[1..] {
+                return Err(EvalError::IncompatibleArrayDimensions {
+                    dims: None,
+                });
+            }
+            dims = vec![
+                ArrayDimension { lower_bound : a_dims[0].lower_bound, length : a_dims[0]
+                .length + b_dims[0].length, }
+            ];
+            dims.extend(&a_dims[1..]);
+        }
+        Ordering::Less => {
+            if &a_dims[..] != &b_dims[1..] {
+                return Err(EvalError::IncompatibleArrayDimensions {
+                    dims: None,
+                });
+            }
+            dims = vec![
+                ArrayDimension { lower_bound : b_dims[0].lower_bound, length : b_dims[0]
+                .length + 1, }
+            ];
+            dims.extend(a_dims);
+        }
+        Ordering::Greater => {
+            if &a_dims[1..] != &b_dims[..] {
+                return Err(EvalError::IncompatibleArrayDimensions {
+                    dims: None,
+                });
+            }
+            dims = vec![
+                ArrayDimension { lower_bound : a_dims[0].lower_bound, length : a_dims[0]
+                .length + 1, }
+            ];
+            dims.extend(b_dims);
+        }
+    }
+    let elems = a_array.elements().iter().chain(b_array.elements().iter());
+    Ok(temp_storage.try_make_datum(|packer| packer.try_push_array(&dims, elems))?)
+}

src/expr/src/scalar/snapshots/mz_expr__scalar__func__array_contains.snap

@@ -0,0 +1,67 @@
+---
+source: src/expr/src/scalar/func.rs
+expression: "#[sqlfunc(\n    output_type = \"bool\",\n    is_infix_op = true,\n    sqlname = \"array_contains\",\n    propagates_nulls = true,\n    introduces_nulls = false\n)]\nfn array_contains<'a>(a: Datum<'a>, b: Datum<'a>) -> Datum<'a> {\n    let array = Datum::unwrap_array(&b);\n    Datum::from(array.elements().iter().any(|e| e == a))\n}\n"
+---
+#[derive(
+    proptest_derive::Arbitrary,
+    Ord,
+    PartialOrd,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    serde::Serialize,
+    serde::Deserialize,
+    Hash,
+    mz_lowertest::MzReflect
+)]
+pub struct ArrayContains;
+impl<'a> crate::func::binary::EagerBinaryFunc<'a> for ArrayContains {
+    type Input1 = Datum<'a>;
+    type Input2 = Datum<'a>;
+    type Output = Datum<'a>;
+    fn call(
+        &self,
+        a: Self::Input1,
+        b: Self::Input2,
+        temp_storage: &'a mz_repr::RowArena,
+    ) -> Self::Output {
+        array_contains(a, b)
+    }
+    fn output_type(
+        &self,
+        input_type_a: mz_repr::ColumnType,
+        input_type_b: mz_repr::ColumnType,
+    ) -> mz_repr::ColumnType {
+        use mz_repr::AsColumnType;
+        let output = <bool>::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)),
+            )
+    }
+    fn introduces_nulls(&self) -> bool {
+        false
+    }
+    fn is_infix_op(&self) -> bool {
+        true
+    }
+    fn propagates_nulls(&self) -> bool {
+        true
+    }
+}
+impl std::fmt::Display for ArrayContains {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.write_str("array_contains")
+    }
+}
+fn array_contains<'a>(a: Datum<'a>, b: Datum<'a>) -> Datum<'a> {
+    let array = Datum::unwrap_array(&b);
+    Datum::from(array.elements().iter().any(|e| e == a))
+}

src/expr/src/scalar/snapshots/mz_expr__scalar__func__array_contains_array.snap

@@ -0,0 +1,72 @@
+---
+source: src/expr/src/scalar/func.rs
+expression: "#[sqlfunc(\n    output_type = \"bool\",\n    is_infix_op = true,\n    sqlname = \"@>\",\n    propagates_nulls = true,\n    introduces_nulls = false\n)]\nfn array_contains_array<'a>(a: Datum<'a>, b: Datum<'a>) -> Datum<'a> {\n    let a = a.unwrap_array().elements();\n    let b = b.unwrap_array().elements();\n    if b.iter().contains(&Datum::Null) {\n        Datum::False\n    } else {\n        b.iter().all(|item_b| a.iter().any(|item_a| item_a == item_b)).into()\n    }\n}\n"
+---
+#[derive(
+    proptest_derive::Arbitrary,
+    Ord,
+    PartialOrd,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    serde::Serialize,
+    serde::Deserialize,
+    Hash,
+    mz_lowertest::MzReflect
+)]
+pub struct ArrayContainsArray;
+impl<'a> crate::func::binary::EagerBinaryFunc<'a> for ArrayContainsArray {
+    type Input1 = Datum<'a>;
+    type Input2 = Datum<'a>;
+    type Output = Datum<'a>;
+    fn call(
+        &self,
+        a: Self::Input1,
+        b: Self::Input2,
+        temp_storage: &'a mz_repr::RowArena,
+    ) -> Self::Output {
+        array_contains_array(a, b)
+    }
+    fn output_type(
+        &self,
+        input_type_a: mz_repr::ColumnType,
+        input_type_b: mz_repr::ColumnType,
+    ) -> mz_repr::ColumnType {
+        use mz_repr::AsColumnType;
+        let output = <bool>::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)),
+            )
+    }
+    fn introduces_nulls(&self) -> bool {
+        false
+    }
+    fn is_infix_op(&self) -> bool {
+        true
+    }
+    fn propagates_nulls(&self) -> bool {
+        true
+    }
+}
+impl std::fmt::Display for ArrayContainsArray {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.write_str("@>")
+    }
+}
+fn array_contains_array<'a>(a: Datum<'a>, b: Datum<'a>) -> Datum<'a> {
+    let a = a.unwrap_array().elements();
+    let b = b.unwrap_array().elements();
+    if b.iter().contains(&Datum::Null) {
+        Datum::False
+    } else {
+        b.iter().all(|item_b| a.iter().any(|item_a| item_a == item_b)).into()
+    }
+}

src/expr/src/scalar/snapshots/mz_expr__scalar__func__array_contains_array_rev.snap

@@ -0,0 +1,66 @@
+---
+source: src/expr/src/scalar/func.rs
+expression: "#[sqlfunc(\n    output_type = \"bool\",\n    is_infix_op = true,\n    sqlname = \"<@\",\n    propagates_nulls = true,\n    introduces_nulls = false\n)]\nfn array_contains_array_rev<'a>(a: Datum<'a>, b: Datum<'a>) -> Datum<'a> {\n    array_contains_array(a, b)\n}\n"
+---
+#[derive(
+    proptest_derive::Arbitrary,
+    Ord,
+    PartialOrd,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    serde::Serialize,
+    serde::Deserialize,
+    Hash,
+    mz_lowertest::MzReflect
+)]
+pub struct ArrayContainsArrayRev;
+impl<'a> crate::func::binary::EagerBinaryFunc<'a> for ArrayContainsArrayRev {
+    type Input1 = Datum<'a>;
+    type Input2 = Datum<'a>;
+    type Output = Datum<'a>;
+    fn call(
+        &self,
+        a: Self::Input1,
+        b: Self::Input2,
+        temp_storage: &'a mz_repr::RowArena,
+    ) -> Self::Output {
+        array_contains_array_rev(a, b)
+    }
+    fn output_type(
+        &self,
+        input_type_a: mz_repr::ColumnType,
+        input_type_b: mz_repr::ColumnType,
+    ) -> mz_repr::ColumnType {
+        use mz_repr::AsColumnType;
+        let output = <bool>::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)),
+            )
+    }
+    fn introduces_nulls(&self) -> bool {
+        false
+    }
+    fn is_infix_op(&self) -> bool {
+        true
+    }
+    fn propagates_nulls(&self) -> bool {
+        true
+    }
+}
+impl std::fmt::Display for ArrayContainsArrayRev {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.write_str("<@")
+    }
+}
+fn array_contains_array_rev<'a>(a: Datum<'a>, b: Datum<'a>) -> Datum<'a> {
+    array_contains_array(a, b)
+}

src/expr/src/scalar/snapshots/mz_expr__scalar__func__array_length.snap

@@ -1,6 +1,6 @@
 ---
 source: src/expr/src/scalar/func.rs
-expression: "#[sqlfunc(\n    is_monotone = \"(false, false)\",\n    output_type = \"Option<i32>\",\n    is_infix_op = true,\n    sqlname = \"array_length\",\n    propagates_nulls = true,\n    introduces_nulls = true\n)]\nfn array_length<'a>(a: Datum<'a>, b: Datum<'a>) -> Result<Datum<'a>, EvalError> {\n    let i = match usize::try_from(b.unwrap_int64()) {\n        Ok(0) | Err(_) => return Ok(Datum::Null),\n        Ok(n) => n - 1,\n    };\n    Ok(\n        match a.unwrap_array().dims().into_iter().nth(i) {\n            None => Datum::Null,\n            Some(dim) => {\n                Datum::Int32(\n                    dim\n                        .length\n                        .try_into()\n                        .map_err(|_| EvalError::Int32OutOfRange(\n                            dim.length.to_string().into(),\n                        ))?,\n                )\n            }\n        },\n    )\n}\n"
+expression: "#[sqlfunc(\n    output_type = \"Option<i32>\",\n    is_infix_op = true,\n    sqlname = \"array_length\",\n    propagates_nulls = true,\n    introduces_nulls = true\n)]\nfn array_length<'a>(a: Datum<'a>, b: Datum<'a>) -> Result<Datum<'a>, EvalError> {\n    let i = match usize::try_from(b.unwrap_int64()) {\n        Ok(0) | Err(_) => return Ok(Datum::Null),\n        Ok(n) => n - 1,\n    };\n    Ok(\n        match a.unwrap_array().dims().into_iter().nth(i) {\n            None => Datum::Null,\n            Some(dim) => {\n                Datum::Int32(\n                    dim\n                        .length\n                        .try_into()\n                        .map_err(|_| EvalError::Int32OutOfRange(\n                            dim.length.to_string().into(),\n                        ))?,\n                )\n            }\n        },\n    )\n}\n"
 ---
 #[derive(
     proptest_derive::Arbitrary,
@@ -52,9 +52,6 @@ impl<'a> crate::func::binary::EagerBinaryFunc<'a> for ArrayLength {
     fn is_infix_op(&self) -> bool {
         true
     }
-    fn is_monotone(&self) -> (bool, bool) {
-        (false, false)
-    }
     fn propagates_nulls(&self) -> bool {
         true
     }