diff --git a/Cargo.lock b/Cargo.lock
index 489f660ec..b045cd066 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1587,6 +1587,7 @@ dependencies = [
  "arrow-array",
  "arrow-buffer",
  "arrow-schema",
+ "arrow-select",
  "codspeed-criterion-compat",
  "krishiv-common",
  "libm",
diff --git a/crates/krishiv-exec/src/planner/eval/hof.rs b/crates/krishiv-exec/src/planner/eval/hof.rs
new file mode 100644
index 000000000..97f07efa7
--- /dev/null
+++ b/crates/krishiv-exec/src/planner/eval/hof.rs
@@ -0,0 +1,672 @@
+// SPDX-License-Identifier: Apache-2.0
+//! Higher-order functions over arrays: `transform`, `filter`, `exists` and
+//! `forall`. The lambda body compiles once against a flattened batch, then
+//! evaluates once per batch over every list element; the list kernels only
+//! reshape (see `krishiv_kernels::list`).
+//!
+//! For a batch of `rows` rows whose lists hold `total` elements, the
+//! flattened batch has `total` rows: the lambda's element column is the
+//! list's child values, its index column (two-variable `transform`) counts
+//! positions within each list, and every captured outer column repeats its
+//! row's value per element (through the lists' offsets). The body runs
+//! once over that batch — never one evaluation per element — and the
+//! result rebuilds the lists with the original offsets (NULL lists stay
+//! NULL).
+
+use std::sync::Arc;
+
+use arrow_array::cast::AsArray;
+use arrow_array::{Array, ArrayRef, Int32Array, ListArray, RecordBatch, UInt32Array};
+use arrow_schema::{DataType as ArrowType, Field, Schema};
+use krishiv_kernels::list;
+use krishiv_plan::{AttrId, BoundColumn, Expr, ExprNode, ResolvedExpr, ResolvedFunction};
+
+use super::{Input, PhysExpr, Value};
+use crate::error::Result;
+use crate::planner::build::{internal, unsupported};
+use krishiv_common::error::KrishivError;
+
+/// Whether `compile` handles `name` here (the analyzer's higher-order
+/// functions over arrays).
+pub(super) fn is_supported(name: &str) -> bool {
+    matches!(name, "transform" | "filter" | "exists" | "forall")
+}
+
+/// Compiles the higher-order call `f` (see the module doc).
+///
+/// # Errors
+/// An engine error when the plan is not what the analyzer resolves.
+pub(super) fn compile(
+    name: &str,
+    f: &ResolvedFunction,
+    input: Input<'_>,
+    _e: &Expr,
+) -> Result<Arc<dyn PhysExpr>> {
+    let [array_expr, lambda_expr] = f.args.as_slice() else {
+        return Err(internal("a higher-order call without its array and lambda"));
+    };
+    let ExprNode::Lambda { params, body } = &lambda_expr.node else {
+        return Err(internal("a higher-order call without a lambda"));
+    };
+    let array = super::compile(array_expr, input)?;
+    let ArrowType::List(field) = array.data_type().clone() else {
+        return Err(internal("a higher-order call over a non-list"));
+    };
+    let mut refs = Refs::default();
+    collect(body, params, &mut Vec::new(), &mut refs);
+    // The flattened batch's columns: the captured outer columns, then this
+    // call's element variables and index. A scalar subquery reads the root
+    // batch, which a nested call no longer sees, so bodies may not hold
+    // one.
+    if refs
+        .outer
+        .iter()
+        .any(|id| input.subqueries.iter().any(|(a, _)| a == id))
+    {
+        return Err(unsupported("scalar subqueries in lambda functions"));
+    }
+    let mut layout: Vec<AttrId> = Vec::new();
+    let mut fields: Vec<Field> = Vec::new();
+    let mut sources: Vec<Source> = Vec::new();
+    for id in refs.outer {
+        let index = input
+            .layout
+            .iter()
+            .position(|a| *a == id)
+            .ok_or_else(|| internal("a higher-order capture outside its input"))?;
+        let field = input.schema.field(index);
+        layout.push(id);
+        // The real nullability: bindings of nested values read it.
+        fields.push(Field::new(
+            format!("c{}", fields.len()),
+            field.data_type().clone(),
+            field.is_nullable(),
+        ));
+        sources.push(Source::Root(index));
+    }
+    for var in refs.outer_lambda {
+        let index = input
+            .layout
+            .iter()
+            .position(|a| *a == var.id)
+            .ok_or_else(|| internal("an enclosing lambda variable outside its input"))?;
+        layout.push(var.id);
+        fields.push(Field::new(
+            format!("c{}", fields.len()),
+            var.data_type.to_arrow(),
+            var.nullable,
+        ));
+        // An enclosing call flattened this variable already: like a root
+        // column, it repeats per element of this call's lists.
+        sources.push(Source::Root(index));
+    }
+    let element = field.data_type().clone();
+    let element_nullable = field.is_nullable();
+    for id in refs.lambda {
+        layout.push(id);
+        fields.push(Field::new(
+            format!("c{}", fields.len()),
+            element.clone(),
+            element_nullable,
+        ));
+        sources.push(Source::Element);
+    }
+    if let Some(id) = refs.index {
+        layout.push(id);
+        fields.push(Field::new(
+            format!("c{}", fields.len()),
+            ArrowType::Int32,
+            false,
+        ));
+        sources.push(Source::Index);
+    }
+    let schema = Arc::new(Schema::new(fields));
+    let body = super::compile(
+        body,
+        Input {
+            layout: &layout,
+            schema: &schema,
+            env: input.env,
+            subqueries: input.subqueries,
+        },
+    )?;
+    let out = f.data_type.to_arrow();
+    Ok(Arc::new(Call {
+        name: name.to_owned(),
+        array,
+        body,
+        sources,
+        out,
+        nullable: f.nullable,
+    }))
+}
+
+/// The columns a lambda body reads: root columns and enclosing calls'
+/// lambda variables (each level carries what the levels below need), and
+/// this call's element and index variables.
+#[derive(Default)]
+struct Refs {
+    /// Captured root columns, in first-use order.
+    outer: Vec<AttrId>,
+    /// Enclosing calls' lambda variables, in first-use order.
+    outer_lambda: Vec<BoundColumn>,
+    /// This call's element variables, in first-use order.
+    lambda: Vec<AttrId>,
+    /// This call's index variable, if used.
+    index: Option<AttrId>,
+}
+
+/// Collects `refs` from `body` against `params`, the current call's
+/// parameters with their stable identities (a nested call collects its own
+/// variables when it compiles: here its parameters only shadow, through
+/// `below`). A variable of an enclosing call is an outer reference here,
+/// carried through this level's flattened batch. Matching is by
+/// [`AttrId`], never by name, so case sensitivity cannot change it.
+fn collect(body: &Arc<Expr>, params: &[BoundColumn], below: &mut Vec<AttrId>, refs: &mut Refs) {
+    match &body.node {
+        ExprNode::Lambda {
+            params: inner,
+            body: nested,
+        } => {
+            // The nested call collects its own variables when it compiles:
+            // this pass only gathers what the current level carries, so its
+            // parameters stay in scope and the nested ones shadow them.
+            below.extend(inner.iter().map(|p| p.id));
+            collect(nested, params, below, refs);
+            below.truncate(below.len() - inner.len());
+        }
+        ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => {
+            if below.contains(&c.id) {
+                // A variable a nested call binds is that call's own: its
+                // flattening carries it, never this one.
+            } else if params.first().is_some_and(|p| p.id == c.id) {
+                // This call's element variable, used directly or from a
+                // nested lambda: the flattened batch carries one element
+                // column per use, so both read it here.
+                if !refs.lambda.contains(&c.id) {
+                    refs.lambda.push(c.id);
+                }
+            } else if params.iter().skip(1).any(|p| p.id == c.id) {
+                if refs.index.is_none() {
+                    refs.index = Some(c.id);
+                }
+            } else {
+                // Bound outside the current call: carried by this level's
+                // flattened batch.
+                if !refs.outer_lambda.iter().any(|v| v.id == c.id) {
+                    refs.outer_lambda.push(c.clone());
+                }
+            }
+        }
+        ExprNode::Resolved(ResolvedExpr::Column(c)) => {
+            if !refs.outer.contains(&c.id) {
+                refs.outer.push(c.id);
+            }
+        }
+        _ => body.for_each_child(&mut |c| collect(c, params, below, refs)),
+    }
+}
+
+/// Where one flattened-batch column comes from: every source repeats one
+/// value per element of its row.
+#[derive(Debug, Clone, Copy)]
+enum Source {
+    /// The input batch's column (a root column, or an enclosing flattened
+    /// batch's column for a nested call), repeated per element.
+    Root(usize),
+    /// The list's child values.
+    Element,
+    /// Positions within each list.
+    Index,
+}
+
+/// A count that does not fit its carrier.
+fn too_many(n: usize) -> KrishivError {
+    internal(&format!("a higher-order batch of {n} rows"))
+}
+
+/// A bound higher-order call.
+#[derive(Debug)]
+struct Call {
+    name: String,
+    array: Arc<dyn PhysExpr>,
+    body: Arc<dyn PhysExpr>,
+    sources: Vec<Source>,
+    out: ArrowType,
+    nullable: bool,
+}
+
+impl PhysExpr for Call {
+    fn data_type(&self) -> &ArrowType {
+        &self.out
+    }
+
+    fn nullable(&self) -> bool {
+        self.nullable
+    }
+
+    fn eval(&self, batch: &RecordBatch, partition: u32) -> Result<Value> {
+        let rows = batch.num_rows();
+        let array = self.array.eval(batch, partition)?.into_array(rows)?;
+        if array.len() != rows {
+            return Err(internal("a higher-order array of the wrong row count"));
+        }
+        let list = array
+            .as_list_opt::<i32>()
+            .ok_or_else(|| internal("a higher-order array that is no list"))?;
+        // Rebase a sliced list to zero-based offsets once: a slice keeps
+        // the absolute offsets, so `offsets[0]` may be non-zero while the
+        // kernels see zero-based lists.
+        let at = |offsets: &[i32], i: usize| {
+            usize::try_from(offsets[i])
+                .map_err(|_| internal("a higher-order list with a negative offset"))
+        };
+        let offsets = list.value_offsets();
+        let base = at(offsets, 0)?;
+        let end = at(offsets, rows)?;
+        let total = end
+            .checked_sub(base)
+            .ok_or_else(|| internal("a higher-order list with decreasing offsets"))?;
+        let rebased = {
+            let mut norm = Vec::with_capacity(rows + 1);
+            for i in 0..=rows {
+                let v = at(offsets, i)?
+                    .checked_sub(base)
+                    .ok_or_else(|| internal("a higher-order list with decreasing offsets"))?;
+                norm.push(
+                    i32::try_from(v)
+                        .map_err(|_| internal("a higher-order list with a negative offset"))?,
+                );
+            }
+            ListArray::new(
+                Arc::clone(list.value_field()),
+                arrow_buffer::OffsetBuffer::new(arrow_buffer::ScalarBuffer::from(norm)),
+                list.values().slice(base, total),
+                list.nulls().cloned(),
+            )
+        };
+        let list = &rebased;
+        let offsets = list.value_offsets();
+        let at = |i: usize| {
+            usize::try_from(offsets[i])
+                .map_err(|_| internal("a higher-order list with a negative offset"))
+        };
+        // The row each element belongs to: `offsets[r]..offsets[r+1]`.
+        let mut rows_of: Vec<u32> = Vec::with_capacity(total);
+        for r in 0..rows {
+            let (start, stop) = (at(r)?, at(r.checked_add(1).ok_or_else(|| too_many(rows))?)?);
+            let len = stop
+                .checked_sub(start)
+                .ok_or_else(|| internal("a higher-order list with decreasing offsets"))?;
+            rows_of.extend(std::iter::repeat_n(
+                u32::try_from(r).map_err(|_| too_many(rows))?,
+                len,
+            ));
+        }
+        let rows_of = UInt32Array::from(rows_of);
+        let mut columns: Vec<ArrayRef> = Vec::with_capacity(self.sources.len());
+        for source in &self.sources {
+            columns.push(match source {
+                // A root column, or an enclosing flattened batch's column
+                // for a nested call: repeated per element.
+                Source::Root(index) => {
+                    let values = Arc::clone(batch.column(*index));
+                    arrow_select::take::take(values.as_ref(), &rows_of, None)
+                        .map_err(|e| internal(&e.to_string()))?
+                }
+                Source::Element => list.values().slice(0, total),
+                Source::Index => {
+                    // Positions within each row's run of `rows_of` (built
+                    // above: one entry per element, in row order), so each
+                    // new row restarts the count. The offsets were validated
+                    // non-decreasing there, and a run holds at most `total`
+                    // entries (`total` fits `i32`, as it is an offset), so
+                    // the count cannot overflow.
+                    let mut at_vals: Vec<i32> = Vec::with_capacity(total);
+                    let mut prev: Option<u32> = None;
+                    let mut pos: i32 = 0;
+                    for &r in rows_of.values() {
+                        if prev.replace(r) != Some(r) {
+                            pos = 0;
+                        }
+                        at_vals.push(pos);
+                        pos = pos.saturating_add(1);
+                    }
+                    Arc::new(Int32Array::from(at_vals))
+                }
+            });
+        }
+        let flat = if columns.is_empty() {
+            // A body that reads nothing (a constant lambda) still needs
+            // `total` rows to evaluate over; it ignores the column.
+            RecordBatch::try_new(
+                Arc::new(Schema::new(vec![Field::new("c0", ArrowType::Null, true)])),
+                vec![Arc::new(arrow_array::NullArray::new(total)) as ArrayRef],
+            )
+            .map_err(|e| internal(&e.to_string()))?
+        } else {
+            RecordBatch::try_new(
+                Arc::new(Schema::new(
+                    columns
+                        .iter()
+                        .enumerate()
+                        .map(|(i, c)| Field::new(format!("c{i}"), c.data_type().clone(), true))
+                        .collect::<Vec<_>>(),
+                )),
+                columns,
+            )
+            .map_err(|e| internal(&e.to_string()))?
+        };
+        let body = self.body.eval(&flat, partition)?.into_array(total)?;
+        if body.len() != total {
+            return Err(internal("a higher-order body of the wrong row count"));
+        }
+        let out = match self.name.as_str() {
+            "transform" => {
+                let ArrowType::List(field) = &self.out else {
+                    return Err(internal("a higher-order call over a non-list"));
+                };
+                Arc::new(
+                    list::transform_list(list, &body, field.is_nullable())
+                        .map_err(|e| internal(&e.to_string()))?,
+                ) as ArrayRef
+            }
+            "filter" | "exists" | "forall" => {
+                let keep = body
+                    .as_boolean_opt()
+                    .ok_or_else(|| internal("a higher-order predicate that is no boolean array"))?;
+                if self.name == "filter" {
+                    Arc::new(list::filter_list(list, keep).map_err(|e| internal(&e.to_string()))?)
+                        as ArrayRef
+                } else if self.name == "exists" {
+                    Arc::new(list::exists_list(list, keep).map_err(|e| internal(&e.to_string()))?)
+                        as ArrayRef
+                } else {
+                    Arc::new(list::forall_list(list, keep).map_err(|e| internal(&e.to_string()))?)
+                        as ArrayRef
+                }
+            }
+            _ => return Err(unsupported(&format!("higher-order function {}", self.name))),
+        };
+        if out.data_type() != &self.out {
+            return Err(internal(&format!(
+                "{} returned {} where the analyzer typed {}",
+                self.name,
+                out.data_type(),
+                self.out
+            )));
+        }
+        Ok(Value::Array(out))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow_array::{ArrayRef, BooleanArray, Int32Array, ListArray, RecordBatch};
+    use arrow_buffer::{OffsetBuffer, ScalarBuffer};
+    use arrow_schema::{DataType as ArrowType, Field, Schema, SchemaRef};
+    use krishiv_common::error::ErrorClass;
+    use krishiv_kernels::KernelCtx;
+    use krishiv_plan::{
+        ColumnRef, Expr, ExprNode, FunctionId, FunctionKind, ResolvedExpr, ResolvedFunction,
+    };
+
+    use super::super::{EvalEnv, Input, PhysExpr, Value, compile};
+    use super::{Call, too_many};
+    use crate::error::Result;
+
+    /// A [`PhysExpr`] returning `array` for every batch.
+    #[derive(Debug)]
+    struct Const {
+        data_type: ArrowType,
+        nullable: bool,
+        array: ArrayRef,
+    }
+
+    impl PhysExpr for Const {
+        fn data_type(&self) -> &ArrowType {
+            &self.data_type
+        }
+
+        fn nullable(&self) -> bool {
+            self.nullable
+        }
+
+        fn eval(&self, _batch: &RecordBatch, _partition: u32) -> Result<Value> {
+            Ok(Value::Array(Arc::clone(&self.array)))
+        }
+    }
+
+    fn env() -> EvalEnv {
+        EvalEnv {
+            ansi: true,
+            legacy_statistical_aggregate: false,
+            zone: None,
+            kernels: KernelCtx::new(),
+            query_start_micros: 0,
+            user: Arc::from("test"),
+            seed_salt: Arc::new(std::sync::atomic::AtomicU64::new(0)),
+        }
+    }
+
+    fn col() -> Arc<Expr> {
+        Arc::new(Expr::new(ExprNode::Column(ColumnRef {
+            name: vec!["a".to_owned()],
+            plan_id: None,
+        })))
+    }
+
+    fn lambda() -> Arc<Expr> {
+        Arc::new(Expr::lambda(vec!["x".to_owned()], Expr::column(["x"])))
+    }
+
+    fn func(name: &str, args: Vec<Arc<Expr>>) -> ResolvedFunction {
+        ResolvedFunction {
+            id: FunctionId::Registry {
+                name: name.to_owned(),
+                id: 0,
+            },
+            kind: FunctionKind::Scalar,
+            args,
+            distinct: false,
+            filter: None,
+            data_type: krishiv_types::DataType::Null,
+            nullable: true,
+            deterministic: true,
+        }
+    }
+
+    fn list(offsets: Vec<i32>, values: Vec<i32>) -> ArrayRef {
+        Arc::new(ListArray::new(
+            Arc::new(Field::new("element", ArrowType::Int32, true)),
+            OffsetBuffer::new(ScalarBuffer::from(offsets)),
+            Arc::new(Int32Array::from(values)),
+            None,
+        ))
+    }
+
+    fn batch(rows: usize) -> RecordBatch {
+        let schema: SchemaRef =
+            Arc::new(Schema::new(vec![Field::new("a", ArrowType::Int32, false)]));
+        RecordBatch::try_new(
+            Arc::clone(&schema),
+            vec![Arc::new(Int32Array::from(vec![0; rows])) as ArrayRef],
+        )
+        .unwrap()
+    }
+
+    fn call(name: &str, array: ArrayRef, body: ArrayRef, out: ArrowType) -> Call {
+        Call {
+            name: name.to_owned(),
+            array: Arc::new(Const {
+                data_type: array.data_type().clone(),
+                nullable: false,
+                array,
+            }),
+            body: Arc::new(Const {
+                data_type: body.data_type().clone(),
+                nullable: true,
+                array: body,
+            }),
+            sources: Vec::new(),
+            out,
+            nullable: true,
+        }
+    }
+
+    #[test]
+    fn malformed_calls_are_internal_errors() {
+        let e = env();
+        let schema: SchemaRef = Arc::new(Schema::new(Vec::<Field>::new()));
+        let input = Input {
+            layout: &[],
+            schema: &schema,
+            env: &e,
+            subqueries: &[],
+        };
+        // Without the array and the lambda.
+        let f = func("transform", vec![lambda()]);
+        let err = compile(
+            &Expr::new(ExprNode::Resolved(ResolvedExpr::Function(f))),
+            input,
+        )
+        .unwrap_err();
+        assert_eq!(err.error_class(), ErrorClass::InternalError);
+        assert!(
+            err.to_string()
+                .contains("a higher-order call without its array and lambda"),
+            "{err}"
+        );
+        // Without a lambda as the second argument (the array never compiles).
+        let f = func("transform", vec![col(), col()]);
+        let err = compile(
+            &Expr::new(ExprNode::Resolved(ResolvedExpr::Function(f))),
+            input,
+        )
+        .unwrap_err();
+        assert_eq!(err.error_class(), ErrorClass::InternalError);
+        assert!(
+            err.to_string()
+                .contains("a higher-order call without a lambda"),
+            "{err}"
+        );
+    }
+
+    #[test]
+    fn too_many_names_the_row_count() {
+        let err = too_many(5);
+        assert_eq!(err.error_class(), ErrorClass::InternalError);
+        assert!(err.to_string().contains('5'), "{err}");
+    }
+
+    #[test]
+    fn mismatched_batches_are_internal_errors() {
+        // The array holds one row where the batch holds two.
+        let c = call(
+            "transform",
+            Arc::new(Int32Array::from(vec![1])),
+            Arc::new(Int32Array::from(vec![1, 2])),
+            ArrowType::Boolean,
+        );
+        let err = c.eval(&batch(2), 0).unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("a higher-order array of the wrong row count"),
+            "{err}"
+        );
+        // The body holds three values for two elements.
+        let c = call(
+            "transform",
+            list(vec![0, 2], vec![5, 6]),
+            Arc::new(Int32Array::from(vec![1, 2, 3])),
+            ArrowType::Boolean,
+        );
+        let err = c.eval(&batch(1), 0).unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("a higher-order body of the wrong row count"),
+            "{err}"
+        );
+    }
+
+    #[test]
+    fn a_transform_over_a_non_list_is_an_internal_error() {
+        let c = call(
+            "transform",
+            list(vec![0, 2], vec![5, 6]),
+            Arc::new(Int32Array::from(vec![7, 8])),
+            ArrowType::Int32,
+        );
+        let err = c.eval(&batch(1), 0).unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("a higher-order call over a non-list"),
+            "{err}"
+        );
+    }
+
+    #[test]
+    fn an_unknown_higher_order_function_is_unsupported() {
+        let c = call(
+            "bogus",
+            list(vec![0, 2], vec![5, 6]),
+            Arc::new(BooleanArray::from(vec![true, false])),
+            ArrowType::Boolean,
+        );
+        let err = c.eval(&batch(1), 0).unwrap_err();
+        assert_eq!(err.error_class(), ErrorClass::KrishivUnsupportedFeature);
+        assert!(
+            err.to_string().contains("higher-order function bogus"),
+            "{err}"
+        );
+    }
+
+    #[test]
+    fn a_sliced_list_rebases_to_zero_based_offsets() {
+        use arrow_array::Array as _;
+        use arrow_array::cast::AsArray as _;
+        // `[[1, 2], [3]]` sliced to its second row: absolute offsets
+        // `[2, 3]` with one element.
+        let sliced = list(vec![0, 2, 3], vec![1, 2, 3]).slice(1, 1);
+        let mut c = call(
+            "transform",
+            sliced,
+            Arc::new(Int32Array::from(vec![9])),
+            ArrowType::List(Arc::new(Field::new("element", ArrowType::Int32, true))),
+        );
+        c.sources = vec![super::Source::Element];
+        let out = c.eval(&batch(1), 0).unwrap().into_array(1).unwrap();
+        let out = out.as_list::<i32>();
+        assert_eq!(out.len(), 1);
+        assert_eq!(out.value_offsets(), &[0, 1]);
+        assert_eq!(
+            out.values()
+                .as_primitive::<arrow_array::types::Int32Type>()
+                .values(),
+            &[9]
+        );
+    }
+
+    #[test]
+    fn a_body_of_an_unexpected_type_is_an_internal_error() {
+        let out = ArrowType::List(Arc::new(Field::new("element", ArrowType::Utf8, true)));
+        let c = call(
+            "transform",
+            list(vec![0, 2], vec![5, 6]),
+            Arc::new(Int32Array::from(vec![7, 8])),
+            out,
+        );
+        let err = c.eval(&batch(1), 0).unwrap_err();
+        assert_eq!(err.error_class(), ErrorClass::InternalError);
+        assert!(
+            err.to_string().contains("transform returned List(Int32"),
+            "{err}"
+        );
+        assert!(
+            err.to_string().contains("analyzer typed List(Utf8"),
+            "{err}"
+        );
+    }
+}
diff --git a/crates/krishiv-exec/src/planner/eval/mod.rs b/crates/krishiv-exec/src/planner/eval/mod.rs
index f2f578889..dd9f62221 100644
--- a/crates/krishiv-exec/src/planner/eval/mod.rs
+++ b/crates/krishiv-exec/src/planner/eval/mod.rs
@@ -27,6 +27,7 @@ mod cast;
 mod cond;
 mod field;
 mod func;
+mod hof;
 mod logic;
 mod nested_cast;
 mod strings;
@@ -43,7 +44,7 @@ use krishiv_common::config::{
 };
 use krishiv_kernels::KernelCtx;
 use krishiv_plan::{
-    AttrId, Builtin, Expr, ExprNode, FunctionId, FunctionKind, Literal, ResolvedExpr,
+    AttrId, BoundColumn, Builtin, Expr, ExprNode, FunctionId, FunctionKind, Literal, ResolvedExpr,
     ResolvedFunction,
 };
 
@@ -212,7 +213,9 @@ impl EvalEnv {
         }
     }
 
-    /// The environment a plan fixed, with this worker's kernels.
+    /// The environment a plan fixed, with this worker's kernels. Lambda
+    /// variables match by stable identity, so no name-resolution flag is
+    /// plan data.
     pub(crate) fn from_plan(env: &ExprEnv) -> Self {
         Self {
             ansi: env.ansi,
@@ -250,6 +253,23 @@ pub(crate) struct Input<'a> {
     pub(crate) subqueries: &'a [(AttrId, Arc<dyn PhysExpr>)],
 }
 
+/// A column of `input`'s batch: the layout position's field. A lambda
+/// variable reads such a column of the flattened batch the higher-order
+/// call compiled around the body (see `hof`).
+fn column(input: Input<'_>, c: &BoundColumn) -> Result<Arc<dyn PhysExpr>> {
+    let index = input
+        .layout
+        .iter()
+        .position(|a| *a == c.id)
+        .ok_or_else(|| internal(&format!("attribute #{} is not an input column", c.id.0)))?;
+    let field = input.schema.field(index);
+    Ok(Arc::new(Column {
+        index,
+        data_type: field.data_type().clone(),
+        nullable: field.is_nullable(),
+    }))
+}
+
 /// Compiles `e` over `input`.
 pub(crate) fn compile(e: &Expr, input: Input<'_>) -> Result<Arc<dyn PhysExpr>> {
     match &e.node {
@@ -258,20 +278,11 @@ pub(crate) fn compile(e: &Expr, input: Input<'_>) -> Result<Arc<dyn PhysExpr>> {
             if let Some((_, v)) = input.subqueries.iter().find(|(a, _)| *a == c.id) {
                 return Ok(Arc::clone(v));
             }
-            let index = input
-                .layout
-                .iter()
-                .position(|a| *a == c.id)
-                .ok_or_else(|| {
-                    internal(&format!("attribute #{} is not an input column", c.id.0))
-                })?;
-            let field = input.schema.field(index);
-            Ok(Arc::new(Column {
-                index,
-                data_type: field.data_type().clone(),
-                nullable: field.is_nullable(),
-            }))
+            column(input, c)
         }
+        // A lambda variable: a column of the flattened batch the
+        // higher-order call compiled around the body (see `hof`).
+        ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => column(input, c),
         ExprNode::Resolved(ResolvedExpr::Alias { expr, .. }) => compile(expr, input),
         ExprNode::Resolved(ResolvedExpr::Field {
             base,
@@ -287,6 +298,11 @@ pub(crate) fn compile(e: &Expr, input: Input<'_>) -> Result<Arc<dyn PhysExpr>> {
         ),
         ExprNode::Cast { expr, to, mode } => cast::compile(compile(expr, input)?, to, *mode, input),
         ExprNode::Resolved(ResolvedExpr::Function(f)) if f.kind == FunctionKind::Scalar => {
+            if let FunctionId::Registry { name, .. } = &f.id
+                && hof::is_supported(name)
+            {
+                return hof::compile(name, f, input, e);
+            }
             let args = f
                 .args
                 .iter()
diff --git a/crates/krishiv-functions/src/python_wrappers/table.rs b/crates/krishiv-functions/src/python_wrappers/table.rs
index 675b2218f..bf74045c6 100644
--- a/crates/krishiv-functions/src/python_wrappers/table.rs
+++ b/crates/krishiv-functions/src/python_wrappers/table.rs
@@ -43,6 +43,22 @@ pub(super) const NOT_EXPORTED: &[(&str, &str)] = &[
         "pow",
         "an alias of `power`; the exported `pow` is a row that sends `power`",
     ),
+    (
+        "transform",
+        "takes a lambda; the Python `Column` API cannot build lambdas yet",
+    ),
+    (
+        "filter",
+        "takes a lambda; the Python `Column` API cannot build lambdas yet",
+    ),
+    (
+        "exists",
+        "takes a lambda; the Python `Column` API cannot build lambdas yet",
+    ),
+    (
+        "forall",
+        "takes a lambda; the Python `Column` API cannot build lambdas yet",
+    ),
 ];
 
 /// Registry names whose wrapper is written by hand in `functions.py`.
@@ -264,7 +280,14 @@ pub(super) fn rows() -> Vec<Row> {
             "col: ColumnOrName, ignoreNulls: bool | Column = None",
         ));
     }
-    for name in ["coalesce", "hash", "named_struct", "struct", "xxhash64"] {
+    for name in [
+        "array",
+        "coalesce",
+        "hash",
+        "named_struct",
+        "struct",
+        "xxhash64",
+    ] {
         rows.push(Row::new(name, "*cols: ColumnOrName"));
     }
     for name in ["lpad", "rpad"] {
diff --git a/crates/krishiv-functions/src/registry/defs.rs b/crates/krishiv-functions/src/registry/defs.rs
index e673d5d5d..080e919c0 100644
--- a/crates/krishiv-functions/src/registry/defs.rs
+++ b/crates/krishiv-functions/src/registry/defs.rs
@@ -852,6 +852,7 @@ pub(super) fn specs() -> Vec<Spec> {
     out.extend(super::url::specs());
     out.extend(super::csv::specs());
     out.extend(super::text::specs());
+    out.extend(super::hof::specs());
     out.extend(super::r#struct::specs());
     out
 }
diff --git a/crates/krishiv-functions/src/registry/hof.rs b/crates/krishiv-functions/src/registry/hof.rs
new file mode 100644
index 000000000..fd7433875
--- /dev/null
+++ b/crates/krishiv-functions/src/registry/hof.rs
@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: Apache-2.0
+//! The analysis signatures of the higher-order functions over arrays
+//! (`transform`, `filter`, `exists`, `forall`) and the `array`
+//! constructor they need (Spark's `ArrayHigherOrderFunction`s and
+//! `CreateArray`).
+//!
+//! The analyzer binds a lambda's variables before the generic path types
+//! the call (see `krishiv-plan`'s `hof`): at a lambda position the
+//! argument's type is its body's, so these rules read the body type from
+//! the argument. The executor compiles the bodies (see `krishiv-exec`'s
+//! `hof`); only `array` binds a kernel here.
+//!
+//! `array` is the minimal constructor this family needs (all arguments at
+//! their common type, as Spark's `CreateArray` types them). The collection
+//! functions own its completion (nested coercion edge cases).
+
+use krishiv_common::error::{DatatypeMismatchUnexpectedInputType, InternalError, KrishivError};
+use krishiv_types::{ArrayType, DataType};
+
+use super::Execution;
+use super::defs::Spec;
+use crate::signature::{ArgType, CallTypes, FunctionKind, Inputs};
+
+/// `array(...)`: an array of the arguments' common type (Spark's
+/// `CreateArray`; untyped `NULL` is `VOID`). The analyzer casts the
+/// arguments to their common type first.
+fn array_result(c: &CallTypes<'_>) -> Result<ArgType, KrishivError> {
+    let element = c.args().first().and_then(|a| a.data_type.clone());
+    let nullable = c.args().iter().any(|a| a.nullable);
+    Ok(ArgType::new(
+        DataType::Array(ArrayType::new(element.unwrap_or(DataType::Null), nullable).into()),
+        false,
+    ))
+}
+
+/// The call's SQL as Spark quotes it in errors: `name(arg, ...)`.
+fn call_sql(name: &str, c: &CallTypes<'_>) -> String {
+    let args: Vec<String> = (0..c.args().len())
+        .map(|i| c.sql(i).unwrap_or_default())
+        .collect();
+    format!("\"{name}({})\"", args.join(", "))
+}
+
+/// A type as Spark's message parameters quote it (`"VOID"` for untyped
+/// `NULL`).
+fn quoted(t: Option<&DataType>) -> String {
+    format!("\"{}\"", t.map_or_else(|| "VOID".to_owned(), DataType::sql))
+}
+
+/// The array argument's element type, `containsNull` and nullability, or
+/// the `UNEXPECTED_INPUT_TYPE` error quoting it (Spark's
+/// `checkInputDataTypes`). The arity check runs before typing, so a
+/// missing argument is an internal error.
+fn array_argument(name: &str, c: &CallTypes<'_>) -> Result<(DataType, bool, bool), KrishivError> {
+    let Some(arg) = c.args().first() else {
+        return Err(InternalError {
+            message: format!("{name} typed without its array argument"),
+        }
+        .into());
+    };
+    match &arg.data_type {
+        Some(DataType::Array(element)) => Ok((
+            element.element_type().clone(),
+            element.contains_null(),
+            arg.nullable,
+        )),
+        other => Err(DatatypeMismatchUnexpectedInputType {
+            sql_expr: call_sql(name, c),
+            param_index: "first".to_owned(),
+            required_type: "\"ARRAY\"".to_owned(),
+            input_sql: format!("\"{}\"", c.sql(0).unwrap_or_default()),
+            input_type: quoted(other.as_ref()),
+        }
+        .into()),
+    }
+}
+
+/// Whether the lambda body (the second argument's type) is boolean, or the
+/// `UNEXPECTED_INPUT_TYPE` error quoting it (Spark quotes the lambda,
+/// constant lambdas wrapped over their hidden variable by the analyzer).
+fn boolean_body(name: &str, c: &CallTypes<'_>) -> Result<bool, KrishivError> {
+    let body = c.args().get(1);
+    match body.and_then(|a| a.data_type.as_ref()) {
+        Some(DataType::Boolean) => Ok(body.is_some_and(|a| a.nullable)),
+        other => Err(DatatypeMismatchUnexpectedInputType {
+            sql_expr: call_sql(name, c),
+            param_index: "second".to_owned(),
+            required_type: "\"BOOLEAN\"".to_owned(),
+            input_sql: c.sql(1).unwrap_or_default(),
+            input_type: quoted(other),
+        }
+        .into()),
+    }
+}
+
+/// `transform(arr, f)`: an array of the body's type.
+fn transform_result(c: &CallTypes<'_>) -> Result<ArgType, KrishivError> {
+    let (_, _, nullable) = array_argument("transform", c)?;
+    let body = c.args().get(1);
+    let element = body
+        .and_then(|a| a.data_type.clone())
+        .unwrap_or(DataType::Null);
+    let contains_null = body.is_none_or(|a| a.nullable);
+    Ok(ArgType::new(
+        DataType::Array(ArrayType::new(element, contains_null).into()),
+        nullable,
+    ))
+}
+
+/// `filter(arr, p)`: the array itself, with a boolean body.
+fn filter_result(c: &CallTypes<'_>) -> Result<ArgType, KrishivError> {
+    let (element, contains_null, nullable) = array_argument("filter", c)?;
+    let _ = boolean_body("filter", c)?;
+    Ok(ArgType::new(
+        DataType::Array(ArrayType::new(element, contains_null).into()),
+        nullable,
+    ))
+}
+
+/// `exists(arr, p)`: a boolean, with a boolean body. The result is
+/// nullable when the array is or when the body is (a NULL mark decides
+/// nothing, so the fold stays NULL). Spark derives nullability from the
+/// array and body alone; `containsNull` is not part of the rule.
+fn exists_result(c: &CallTypes<'_>) -> Result<ArgType, KrishivError> {
+    let (_, _, nullable) = array_argument("exists", c)?;
+    let body_nullable = boolean_body("exists", c)?;
+    Ok(ArgType::new(DataType::Boolean, nullable || body_nullable))
+}
+
+/// `forall(arr, p)`: a boolean, with a boolean body (same nullability
+/// as `exists`: a NULL mark decides nothing either way).
+fn forall_result(c: &CallTypes<'_>) -> Result<ArgType, KrishivError> {
+    let (_, _, nullable) = array_argument("forall", c)?;
+    let body_nullable = boolean_body("forall", c)?;
+    Ok(ArgType::new(DataType::Boolean, nullable || body_nullable))
+}
+
+/// The signatures of this family.
+pub(super) fn specs() -> Vec<Spec> {
+    vec![
+        Spec {
+            name: "array",
+            kind: FunctionKind::Scalar,
+            inputs: Inputs::Common,
+            result: array_result,
+            execution: Execution::Scalar,
+        },
+        Spec {
+            name: "transform",
+            kind: FunctionKind::Scalar,
+            inputs: Inputs::Any,
+            result: transform_result,
+            execution: Execution::HigherOrder,
+        },
+        Spec {
+            name: "filter",
+            kind: FunctionKind::Scalar,
+            inputs: Inputs::Any,
+            result: filter_result,
+            execution: Execution::HigherOrder,
+        },
+        Spec {
+            name: "exists",
+            kind: FunctionKind::Scalar,
+            inputs: Inputs::Any,
+            result: exists_result,
+            execution: Execution::HigherOrder,
+        },
+        Spec {
+            name: "forall",
+            kind: FunctionKind::Scalar,
+            inputs: Inputs::Any,
+            result: forall_result,
+            execution: Execution::HigherOrder,
+        },
+    ]
+}
diff --git a/crates/krishiv-functions/src/registry/mod.rs b/crates/krishiv-functions/src/registry/mod.rs
index 66c6952f5..971415d69 100644
--- a/crates/krishiv-functions/src/registry/mod.rs
+++ b/crates/krishiv-functions/src/registry/mod.rs
@@ -19,6 +19,7 @@ mod conditional;
 mod csv;
 mod defs;
 mod hashing;
+mod hof;
 mod math;
 mod misc;
 mod number;
@@ -51,6 +52,11 @@ pub enum Execution {
     /// By the executor's window operator, over a window (`row_number`,
     /// `rank`, ...); never called without `OVER`.
     Window,
+    /// By the executor's higher-order compiler, which evaluates the lambda
+    /// bodies: `transform`, `filter`, `exists`, `forall`
+    /// (`krishiv_exec::planner::eval::hof`, over `krishiv_kernels::list`).
+    /// A lambda is no Arrow value, so these never bind a kernel here.
+    HigherOrder,
 }
 
 /// The aggregates the executor implements.
diff --git a/crates/krishiv-functions/src/registry/tests.rs b/crates/krishiv-functions/src/registry/tests.rs
index 47c04ed3e..64178fb67 100644
--- a/crates/krishiv-functions/src/registry/tests.rs
+++ b/crates/krishiv-functions/src/registry/tests.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use krishiv_common::error::{ErrorClass, KrishivError};
-use krishiv_types::{DataType, DecimalType};
+use krishiv_types::{ArrayType, DataType, DecimalType};
 
 use super::{Aggregate, Execution, FunctionDef, Lookup, builtins};
 use crate::scalar::scalar_names;
@@ -1845,6 +1845,103 @@ fn regex_signatures() {
     assert_eq!(r, ArgType::new(DataType::Integer, true));
 }
 
+#[test]
+fn hof_signatures() {
+    use DataType::{Array, Boolean, Integer};
+    let array = |e: DataType, contains_null: bool, nullable: bool| {
+        ArgType::new(Array(ArrayType::new(e, contains_null).into()), nullable)
+    };
+    let i = || ty(Integer);
+    let b = || ty(Boolean);
+    // `array(...)`: the common element type; untyped `NULL` is `VOID`,
+    // no arguments an empty `VOID` array.
+    assert_eq!(
+        result("array", &[i(), i()], &[]).unwrap(),
+        array(Integer, false, false)
+    );
+    assert_eq!(
+        result("array", &[ArgType::new(Integer, true), i()], &[]).unwrap(),
+        array(Integer, true, false)
+    );
+    assert_eq!(
+        result("array", &[null_ty(), null_ty()], &[]).unwrap(),
+        array(DataType::Null, true, false)
+    );
+    assert_eq!(
+        result("array", &[], &[]).unwrap(),
+        array(DataType::Null, false, false)
+    );
+    // The higher-order functions type their lambda argument as its body:
+    // `transform` maps the body, `filter` keeps the array, `exists` and
+    // `forall` fold to booleans.
+    let arr = || array(Integer, true, false);
+    assert_eq!(
+        result("transform", &[arr(), i()], &[]).unwrap(),
+        array(Integer, false, false)
+    );
+    assert_eq!(
+        result("transform", &[arr(), ArgType::new(Integer, true)], &[]).unwrap(),
+        array(Integer, true, false)
+    );
+    assert_eq!(result("filter", &[arr(), b()], &[]).unwrap(), arr());
+    assert_eq!(
+        result("exists", &[array(Integer, false, true), b()], &[]).unwrap(),
+        ArgType::new(Boolean, true)
+    );
+    // `exists`/`forall` are nullable when the array is or when the body
+    // is (Spark derives the nullability from the array and the body
+    // alone): only a non-null array with a non-null body folds to a
+    // non-null boolean.
+    assert_eq!(
+        result("forall", &[arr(), b()], &[]).unwrap(),
+        ArgType::new(Boolean, false)
+    );
+    assert_eq!(
+        result(
+            "exists",
+            &[array(Integer, false, false), ArgType::new(Boolean, true)],
+            &[]
+        )
+        .unwrap(),
+        ArgType::new(Boolean, true)
+    );
+    assert_eq!(
+        result("forall", &[array(Integer, false, false), b()], &[]).unwrap(),
+        ArgType::new(Boolean, false)
+    );
+    // The array comes first and holds an array; the predicate is boolean.
+    for name in ["transform", "filter", "exists", "forall"] {
+        let err = result(name, &[i(), i()], &[]).unwrap_err();
+        assert_eq!(
+            err.error_class(),
+            ErrorClass::DatatypeMismatchUnexpectedInputType,
+            "{name}"
+        );
+        assert!(err.to_string().contains("\"ARRAY\""), "{name}: {err}");
+    }
+    for name in ["filter", "exists", "forall"] {
+        let err = result(name, &[arr(), i()], &[]).unwrap_err();
+        assert_eq!(
+            err.error_class(),
+            ErrorClass::DatatypeMismatchUnexpectedInputType,
+            "{name}"
+        );
+        assert!(err.to_string().contains("\"BOOLEAN\""), "{name}: {err}");
+    }
+    // Higher-order calls run in the executor, never in a kernel binding.
+    for name in ["transform", "filter", "exists", "forall"] {
+        assert_eq!(def(name).execution, Execution::HigherOrder, "{name}");
+        assert_eq!(def(name).kind, FunctionKind::Scalar, "{name}");
+    }
+    assert_eq!(def("array").execution, Execution::Scalar);
+    // The arity check runs before typing, so a call typed without its
+    // array argument is an engine bug, never a user error.
+    for name in ["transform", "filter", "exists", "forall"] {
+        let err = result(name, &[], &[]).unwrap_err();
+        assert_eq!(err.error_class(), ErrorClass::InternalError, "{name}");
+    }
+}
+
 #[test]
 fn moment_aggregates_are_registered_as_doubles() {
     let r = builtins();
diff --git a/crates/krishiv-functions/src/scalar/array.rs b/crates/krishiv-functions/src/scalar/array.rs
new file mode 100644
index 000000000..8cf118cdc
--- /dev/null
+++ b/crates/krishiv-functions/src/scalar/array.rs
@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+//! The `array(...)` constructor: one list per row holding each argument's
+//! value (Spark's `CreateArray`). The analyzer casts the arguments to
+//! their common type first; the kernel interleaves them (see
+//! `krishiv_kernels::list::create`).
+
+use std::sync::Arc;
+
+use arrow_array::ArrayRef;
+use arrow_schema::DataType;
+use krishiv_kernels::list;
+
+use super::args::Inputs;
+use super::{BindArg, BindOptions, Binding, FamilyResult, bad_types, listed};
+
+/// Every name this family binds.
+pub(super) const NAMES: &[&str] = &["array"];
+
+/// `array(a, b, ...)`: the arguments share one type (checked here, as the
+/// analyzer's common cast may leave an untyped `NULL` they all share).
+/// No arguments is an empty list per row (Spark's `array()`).
+fn array(args: &[BindArg]) -> Option<Binding> {
+    let first = args
+        .first()
+        .map(BindArg::data_type)
+        .unwrap_or(DataType::Null);
+    if args.iter().any(|a| a.data_type() != first) {
+        return None;
+    }
+    let contains_null = args.iter().any(BindArg::nullable);
+    let return_type = DataType::List(Arc::new(arrow_schema::Field::new(
+        "element",
+        first,
+        contains_null,
+    )));
+    let n = args.len();
+    Some(Binding::new(return_type, move |x: &Inputs<'_>| {
+        let mut args = Vec::with_capacity(n);
+        for i in 0..n {
+            args.push(x.column(i)?);
+        }
+        Ok(Arc::new(list::create(&args, x.rows(), contains_null)?) as ArrayRef)
+    }))
+}
+
+/// Binds the constructor.
+pub(super) fn bind(name: &str, args: &[BindArg], opts: &BindOptions) -> FamilyResult {
+    let _ = opts;
+    let listed = listed(NAMES, name)?;
+    match array(args) {
+        Some(b) => Some((listed, Ok(b))),
+        None => Some((listed, Err(bad_types(listed, args)))),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use krishiv_common::error::ErrorClass;
+
+    use super::*;
+
+    /// Arguments of different types do not bind: the analyzer casts to a
+    /// common type first, so a mismatch here is a type error.
+    #[test]
+    fn mismatched_argument_types_do_not_bind() {
+        let args = vec![
+            BindArg::from(arrow_schema::DataType::Int32),
+            BindArg::from(arrow_schema::DataType::Utf8),
+        ];
+        let (listed_name, binding) = bind("array", &args, &BindOptions::new()).unwrap();
+        assert_eq!(listed_name, "array");
+        let Err(err) = binding else {
+            panic!("mismatched array argument types bound");
+        };
+        assert_eq!(err.error_class(), ErrorClass::KrishivUnsupportedFeature);
+        assert!(err.to_string().contains("array("), "{err}");
+    }
+
+    /// An unlisted name is not this family's to bind.
+    #[test]
+    fn other_names_do_not_bind() {
+        assert!(
+            bind(
+                "transform",
+                &[BindArg::from(arrow_schema::DataType::Int32)],
+                &BindOptions::new()
+            )
+            .is_none()
+        );
+    }
+}
diff --git a/crates/krishiv-functions/src/scalar/mod.rs b/crates/krishiv-functions/src/scalar/mod.rs
index b35f8c1b4..cee46c6a7 100644
--- a/crates/krishiv-functions/src/scalar/mod.rs
+++ b/crates/krishiv-functions/src/scalar/mod.rs
@@ -25,6 +25,7 @@
 
 mod args;
 mod arith;
+mod array;
 mod bitwise;
 mod chars;
 mod codec;
@@ -389,7 +390,8 @@ type FamilyResult = Option<(&'static str, Result<Binding, KrishivError>)>;
 type Binder = fn(&str, &[BindArg], &BindOptions) -> FamilyResult;
 
 /// The families (their names and binder), in lookup order.
-const FAMILIES: [(&[&str], Binder); 16] = [
+const FAMILIES: [(&[&str], Binder); 17] = [
+    (array::NAMES, array::bind),
     (string::NAMES, string::bind),
     (datetime::NAMES, datetime::bind),
     (math::NAMES, math::bind),
diff --git a/crates/krishiv-functions/src/scalar/regex/tests.rs b/crates/krishiv-functions/src/scalar/regex/tests.rs
index 0b334a493..405da8a97 100644
--- a/crates/krishiv-functions/src/scalar/regex/tests.rs
+++ b/crates/krishiv-functions/src/scalar/regex/tests.rs
@@ -1287,14 +1287,8 @@ fn regex_bind_errors() {
     use crate::scalar::{BindArg, bind_scalar};
     use arrow_schema::DataType;
     let opts = crate::scalar::BindOptions::new();
-    let utf8 = || BindArg::Column {
-        ty: DataType::Utf8,
-        nullable: true,
-    };
-    let int = || BindArg::Column {
-        ty: DataType::Int32,
-        nullable: true,
-    };
+    let utf8 = || BindArg::from(DataType::Utf8);
+    let int = || BindArg::from(DataType::Int32);
     for (name, args) in [
         ("regexp_extract", vec![utf8()]),
         ("regexp_extract", vec![utf8(), utf8(), utf8(), int()]),
diff --git a/crates/krishiv-functions/src/scalar/tests/mod.rs b/crates/krishiv-functions/src/scalar/tests/mod.rs
index 9a06369fc..b9d5c8fe0 100644
--- a/crates/krishiv-functions/src/scalar/tests/mod.rs
+++ b/crates/krishiv-functions/src/scalar/tests/mod.rs
@@ -611,17 +611,7 @@ fn session_user_and_local_clock() {
         let out: Vec<_> = out.as_string::<i32>().iter().collect();
         assert_eq!(out, [Some("etl"), Some("etl"), Some("etl")]);
     }
-    assert!(
-        bind_scalar(
-            "current_user",
-            &[BindArg::Column {
-                ty: DataType::Int32,
-                nullable: true
-            }],
-            &opts
-        )
-        .is_err()
-    );
+    assert!(bind_scalar("current_user", &[DataType::Int32.into()], &opts).is_err());
     // `localtimestamp` is the wall clock of the session zone, without a zone.
     let micros = 1_700_000_000_123_456;
     let opts = BindOptions::new()
diff --git a/crates/krishiv-functions/src/scalar/tests/text.rs b/crates/krishiv-functions/src/scalar/tests/text.rs
index f938e5b32..b3f96b030 100644
--- a/crates/krishiv-functions/src/scalar/tests/text.rs
+++ b/crates/krishiv-functions/src/scalar/tests/text.rs
@@ -467,14 +467,8 @@ fn levenshtein_threshold_nulls() {
     // A NULL literal makes the whole call NULL.
     let null = ints(&[None]);
     let args = [
-        BindArg::Column {
-            ty: DataType::Utf8,
-            nullable: true,
-        },
-        BindArg::Column {
-            ty: DataType::Utf8,
-            nullable: true,
-        },
+        BindArg::from(DataType::Utf8),
+        BindArg::from(DataType::Utf8),
         BindArg::Literal(Arc::clone(&null)),
     ];
     let f = bind_scalar("levenshtein", &args, &BindOptions::new()).unwrap();
diff --git a/crates/krishiv-kernels/Cargo.toml b/crates/krishiv-kernels/Cargo.toml
index 1472d490c..7e62f2236 100644
--- a/crates/krishiv-kernels/Cargo.toml
+++ b/crates/krishiv-kernels/Cargo.toml
@@ -15,6 +15,7 @@ workspace = true
 arrow-array.workspace = true
 arrow-buffer.workspace = true
 arrow-schema.workspace = true
+arrow-select.workspace = true
 krishiv-common = { path = "../krishiv-common" }
 libm.workspace = true
 md5.workspace = true
@@ -43,3 +44,7 @@ harness = false
 [[bench]]
 name = "cast"
 harness = false
+
+[[bench]]
+name = "list"
+harness = false
diff --git a/crates/krishiv-kernels/benches/list.rs b/crates/krishiv-kernels/benches/list.rs
new file mode 100644
index 000000000..71f32106c
--- /dev/null
+++ b/crates/krishiv-kernels/benches/list.rs
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+//! List kernel benchmarks (64K rows, one thread; CodSpeed in CI):
+//! `array` interleaves its arguments into one list per row.
+
+#![expect(
+    missing_docs,
+    reason = "criterion_group! generates an undocumented function"
+)]
+#![expect(
+    clippy::unwrap_used,
+    reason = "a broken fixture must fail the bench loudly, not skip it"
+)]
+
+use std::hint::black_box;
+use std::sync::Arc;
+
+use arrow_array::{ArrayRef, Int32Array};
+use criterion::{Criterion, criterion_group, criterion_main};
+
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+const ROWS: usize = 1 << 16;
+
+fn list_benches(c: &mut Criterion) {
+    let cols: Vec<ArrayRef> = (0..3)
+        .map(|k| {
+            let a: Int32Array = (0..ROWS as i64)
+                .map(|i| (i % 10 != k).then(|| (i.wrapping_mul(7919 + k) % 1000) as i32))
+                .collect();
+            Arc::new(a) as ArrayRef
+        })
+        .collect();
+    c.bench_function("array_i32_x3", |bench| {
+        bench.iter(|| krishiv_kernels::list::create(black_box(&cols), ROWS, true).unwrap());
+    });
+}
+
+criterion_group!(benches, list_benches);
+criterion_main!(benches);
diff --git a/crates/krishiv-kernels/src/lib.rs b/crates/krishiv-kernels/src/lib.rs
index 0b4736dbf..a837f181d 100644
--- a/crates/krishiv-kernels/src/lib.rs
+++ b/crates/krishiv-kernels/src/lib.rs
@@ -48,6 +48,7 @@ pub mod error;
 pub mod float;
 pub mod hash;
 pub mod integer;
+pub mod list;
 pub mod math;
 pub mod number_format;
 pub mod ops;
diff --git a/crates/krishiv-kernels/src/list.rs b/crates/krishiv-kernels/src/list.rs
new file mode 100644
index 000000000..10f2ed22e
--- /dev/null
+++ b/crates/krishiv-kernels/src/list.rs
@@ -0,0 +1,265 @@
+// SPDX-License-Identifier: Apache-2.0
+//! List kernels for the higher-order functions: `array` builds a list per
+//! row, and `transform` / `filter` / `exists` / `forall` consume one (see
+//! `krishiv-exec`'s `hof`, which evaluates the lambda bodies).
+//!
+//! Every kernel works on the [`ListArray`] directly, offsets and child
+//! values, never one Rust value per row: the caller evaluates a lambda
+//! body once over the flattened child values, and these kernels only
+//! reshape. A NULL list stays NULL; an empty list stays empty (or is
+//! false for `exists`, true for `forall`).
+//!
+//! Offsets and lengths cross the `i32`/`u32`/`usize` boundary with checked
+//! conversions: a batch that does not fit is an engine error, never a
+//! wrap.
+
+use std::sync::Arc;
+
+use arrow_array::{Array, ArrayRef, BooleanArray, ListArray, NullArray};
+use arrow_buffer::{OffsetBuffer, ScalarBuffer};
+use arrow_schema::{DataType, Field};
+
+use super::error::KernelError;
+
+/// The offsets of `list`, as `usize` pairs. Offsets are non-negative by
+/// construction (`OffsetBuffer`), so they always fit.
+fn ranges(list: &ListArray) -> Vec<(usize, usize)> {
+    use arrow_buffer::ArrowNativeType as _;
+    let offsets = list.value_offsets();
+    let mut out = Vec::with_capacity(list.len());
+    for pair in offsets.windows(2) {
+        out.push((pair[0].as_usize(), pair[1].as_usize()));
+    }
+    out
+}
+
+/// `array(a, b, ...)`: one list per row holding each argument's value
+/// (`[a[r], b[r], ...]`), interleaved in one pass in row-major order. An
+/// empty argument list is an empty list per row. The arguments share one
+/// type (the analyzer casts them); `contains_null` is whether elements may
+/// be null (the analyzer's, from the arguments' nullability).
+///
+/// # Errors
+/// [`KernelError`] when the arguments' lengths disagree with `rows`, or a
+/// length does not fit a 32-bit offset.
+pub fn create(
+    args: &[ArrayRef],
+    rows: usize,
+    contains_null: bool,
+) -> Result<ListArray, KernelError> {
+    for a in args {
+        if a.len() != rows {
+            return Err(KernelError::internal(format!(
+                "array of {rows} rows over an argument of {} rows",
+                a.len()
+            )));
+        }
+    }
+    let len = list_len(rows, args.len())?;
+    if args.is_empty() {
+        let zeros = usize::checked_add(rows, 1).ok_or_else(|| too_big(rows))?;
+        let offsets = OffsetBuffer::new(ScalarBuffer::from(vec![0_i32; zeros]));
+        let values = NullArray::new(0);
+        return Ok(ListArray::new(
+            Arc::new(Field::new("element", DataType::Null, contains_null)),
+            offsets,
+            Arc::new(values),
+            None,
+        ));
+    }
+    let refs: Vec<&dyn Array> = args.iter().map(AsRef::as_ref).collect();
+    // Row `r` takes element `r` of each argument: `(argument, row)` index
+    // pairs interleave the arguments in one pass, in row-major order.
+    let mut indices: Vec<(usize, usize)> = Vec::with_capacity(len);
+    for r in 0..rows {
+        for c in 0..args.len() {
+            indices.push((c, r));
+        }
+    }
+    let values = arrow_select::interleave::interleave(&refs, &indices)
+        .map_err(|e| KernelError::internal(e.to_string()))?;
+    let per_row = i32::try_from(args.len()).map_err(|_| too_big(args.len()))?;
+    let mut offsets = Vec::with_capacity(usize::checked_add(rows, 1).ok_or_else(|| too_big(rows))?);
+    for r in 0..=i32::try_from(rows).map_err(|_| too_big(rows))? {
+        offsets.push(r.checked_mul(per_row).ok_or_else(|| too_big(rows))?);
+    }
+    let field = Arc::new(Field::new(
+        "element",
+        values.data_type().clone(),
+        contains_null,
+    ));
+    Ok(ListArray::new(
+        field,
+        OffsetBuffer::new(ScalarBuffer::from(offsets)),
+        values,
+        None,
+    ))
+}
+
+/// What does not fit a 32-bit offset or index.
+fn too_big(n: usize) -> KernelError {
+    KernelError::internal(format!("a list of {n} rows"))
+}
+
+/// `rows` lists of `per_row` elements: their interleaved length.
+///
+/// # Errors
+/// [`KernelError`] when the length does not fit.
+fn list_len(rows: usize, per_row: usize) -> Result<usize, KernelError> {
+    rows.checked_mul(per_row.max(1))
+        .ok_or_else(|| too_big(rows))
+}
+
+/// `transform(list, values)`: the lists of `list` over the new child
+/// `values` (the body evaluated over the flattened elements). `values`
+/// holds one entry per element of `list`; `contains_null` is the body's
+/// nullability.
+///
+/// # Errors
+/// [`KernelError`] when `values` is shorter than the elements.
+pub fn transform_list(
+    list: &ListArray,
+    values: &ArrayRef,
+    contains_null: bool,
+) -> Result<ListArray, KernelError> {
+    let (_, end) = ranges(list).last().copied().unwrap_or((0, 0));
+    if values.len() < end {
+        return Err(KernelError::internal(format!(
+            "transform over {end} elements with {} values",
+            values.len()
+        )));
+    }
+    let values = if values.len() == end {
+        Arc::clone(values)
+    } else {
+        values.slice(0, end)
+    };
+    let field = Arc::new(Field::new(
+        "element",
+        values.data_type().clone(),
+        contains_null,
+    ));
+    Ok(ListArray::new(
+        field,
+        list.offsets().clone(),
+        values,
+        list.nulls().cloned(),
+    ))
+}
+
+/// `filter(list, keep)`: the elements `keep` marks true (a NULL mark drops
+/// its element, as Spark does). `keep` holds one entry per element of
+/// `list`.
+///
+/// # Errors
+/// [`KernelError`] when `keep` is shorter than the elements, or the kept
+/// length does not fit a 32-bit offset.
+pub fn filter_list(list: &ListArray, keep: &BooleanArray) -> Result<ListArray, KernelError> {
+    let ranges = ranges(list);
+    let (_, end) = ranges.last().copied().unwrap_or((0, 0));
+    if keep.len() < end {
+        return Err(KernelError::internal(format!(
+            "filter over {end} elements with {} marks",
+            keep.len()
+        )));
+    }
+    let mut take: Vec<u32> = Vec::with_capacity(end);
+    let mut offsets = Vec::with_capacity(
+        usize::checked_add(list.len(), 1)
+            .ok_or_else(|| KernelError::internal(format!("a filter over {} lists", list.len())))?,
+    );
+    offsets.push(0_i32);
+    for (i, &(start, stop)) in ranges.iter().enumerate() {
+        if list.is_null(i) {
+            offsets.push(i32::try_from(take.len()).map_err(|_| too_big(take.len()))?);
+            continue;
+        }
+        for e in start..stop {
+            if keep.is_valid(e) && keep.value(e) {
+                take.push(u32::try_from(e).map_err(|_| too_big(e))?);
+            }
+        }
+        offsets.push(i32::try_from(take.len()).map_err(|_| too_big(take.len()))?);
+    }
+    let values = arrow_select::take::take(
+        list.values().as_ref(),
+        &arrow_array::UInt32Array::from(take),
+        None,
+    )
+    .map_err(|e| KernelError::internal(e.to_string()))?;
+    // The elements pass through unchanged: the field rides along.
+    let field = Arc::clone(list.value_field());
+    Ok(ListArray::new(
+        field,
+        OffsetBuffer::new(ScalarBuffer::from(offsets)),
+        values,
+        list.nulls().cloned(),
+    ))
+}
+
+/// Folds `keep` (one entry per element of `list`) to one boolean per list
+/// with Spark's three-valued logic: `any` (`exists`) is true when some
+/// mark is true, else NULL when some mark is NULL, else false; `all`
+/// (`forall`) is false when some mark is false, else NULL when some mark
+/// is NULL, else true. A NULL list stays NULL; an empty one is
+/// `any = false`, `all = true`.
+fn fold_flags(
+    list: &ListArray,
+    keep: &BooleanArray,
+    any: bool,
+) -> Result<BooleanArray, KernelError> {
+    let ranges = ranges(list);
+    let (_, end) = ranges.last().copied().unwrap_or((0, 0));
+    if keep.len() < end {
+        return Err(KernelError::internal(format!(
+            "fold over {end} elements with {} marks",
+            keep.len()
+        )));
+    }
+    let mut out = BooleanArray::builder(list.len());
+    for (i, &(start, stop)) in ranges.iter().enumerate() {
+        if list.is_null(i) {
+            out.append_null();
+            continue;
+        }
+        let mut decided = false;
+        let mut seen_null = false;
+        for e in start..stop {
+            if !keep.is_valid(e) {
+                seen_null = true;
+                continue;
+            }
+            if keep.value(e) == any {
+                decided = true;
+                break;
+            }
+        }
+        if decided {
+            out.append_value(any);
+        } else if seen_null {
+            out.append_null();
+        } else {
+            out.append_value(!any);
+        }
+    }
+    Ok(out.finish())
+}
+
+/// `exists(list, keep)`: whether some element's mark is true.
+///
+/// # Errors
+/// [`KernelError`] when `keep` is shorter than the elements.
+pub fn exists_list(list: &ListArray, keep: &BooleanArray) -> Result<BooleanArray, KernelError> {
+    fold_flags(list, keep, true)
+}
+
+/// `forall(list, keep)`: whether no element's mark is false.
+///
+/// # Errors
+/// [`KernelError`] when `keep` is shorter than the elements.
+pub fn forall_list(list: &ListArray, keep: &BooleanArray) -> Result<BooleanArray, KernelError> {
+    fold_flags(list, keep, false)
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/krishiv-kernels/src/list/tests.rs b/crates/krishiv-kernels/src/list/tests.rs
new file mode 100644
index 000000000..fc1b8d0bf
--- /dev/null
+++ b/crates/krishiv-kernels/src/list/tests.rs
@@ -0,0 +1,267 @@
+// SPDX-License-Identifier: Apache-2.0
+//! Unit tests for the list kernels: nulls, empty lists, nested lists,
+//! large offsets and precondition failures.
+
+use std::sync::Arc;
+
+use arrow_array::cast::AsArray;
+use arrow_array::types::Int32Type;
+use arrow_array::{Array, ArrayRef, BooleanArray, Int32Array, ListArray};
+use arrow_buffer::{NullBuffer, OffsetBuffer, ScalarBuffer};
+use arrow_schema::{DataType, Field};
+
+use super::{create, exists_list, filter_list, forall_list, transform_list};
+
+fn field() -> Arc<Field> {
+    Arc::new(Field::new("element", DataType::Int32, true))
+}
+
+fn list(values: &[Option<Vec<Option<i32>>>]) -> ListArray {
+    let mut ints = Vec::new();
+    let mut offsets = vec![0_i32];
+    let mut nulls = Vec::new();
+    for row in values {
+        match row {
+            None => {
+                nulls.push(false);
+                offsets.push(i32::try_from(ints.len()).unwrap());
+            }
+            Some(items) => {
+                nulls.push(true);
+                for v in items {
+                    ints.push(*v);
+                }
+                offsets.push(i32::try_from(ints.len()).unwrap());
+            }
+        }
+    }
+    ListArray::new(
+        field(),
+        OffsetBuffer::new(ScalarBuffer::from(offsets)),
+        Arc::new(Int32Array::from(ints)),
+        Some(NullBuffer::from(nulls)),
+    )
+}
+
+fn marks(values: Vec<Option<bool>>) -> BooleanArray {
+    values.into_iter().collect()
+}
+
+fn flat(list: &ListArray) -> Vec<Option<i32>> {
+    list.values().as_primitive::<Int32Type>().iter().collect()
+}
+
+fn rows(list: &ListArray) -> Vec<Option<Vec<Option<i32>>>> {
+    let values = flat(list);
+    let offsets = list.value_offsets();
+    (0..list.len())
+        .map(|i| {
+            if list.is_null(i) {
+                return None;
+            }
+            let next = i.checked_add(1).unwrap();
+            let (start, stop) = (
+                usize::try_from(offsets[i]).unwrap(),
+                usize::try_from(offsets[next]).unwrap(),
+            );
+            Some(values[start..stop].to_vec())
+        })
+        .collect()
+}
+
+#[test]
+fn create_interleaves_columns() {
+    let a: ArrayRef = Arc::new(Int32Array::from(vec![Some(1), None, Some(3)]));
+    let b: ArrayRef = Arc::new(Int32Array::from(vec![Some(4), Some(5), None]));
+    let out = create(&[a, b], 3, true).unwrap();
+    assert_eq!(
+        rows(&out),
+        vec![
+            Some(vec![Some(1), Some(4)]),
+            Some(vec![None, Some(5)]),
+            Some(vec![Some(3), None]),
+        ]
+    );
+}
+
+#[test]
+fn create_no_arguments_is_empty() {
+    let out = create(&[], 2, false).unwrap();
+    assert_eq!(out.len(), 2);
+    assert_eq!(out.value_offsets(), &[0, 0, 0]);
+}
+
+#[test]
+fn create_rejects_a_short_argument() {
+    let a: ArrayRef = Arc::new(Int32Array::from(vec![1]));
+    assert!(create(&[a], 2, true).is_err());
+}
+
+#[test]
+fn transform_rebuilds_over_new_values() {
+    // `[1, 2], NULL, [], [3]`, doubled to `[2, 4], NULL, [], [6]`.
+    let input = list(&[
+        Some(vec![Some(1), Some(2)]),
+        None,
+        Some(vec![]),
+        Some(vec![Some(3)]),
+    ]);
+    let values: ArrayRef = Arc::new(Int32Array::from(vec![2, 4, 6]));
+    let out = transform_list(&input, &values, true).unwrap();
+    assert_eq!(
+        rows(&out),
+        vec![
+            Some(vec![Some(2), Some(4)]),
+            None,
+            Some(vec![]),
+            Some(vec![Some(6)]),
+        ]
+    );
+    assert!(out.is_null(1));
+}
+
+#[test]
+fn transform_rejects_short_values() {
+    let input = list(&[Some(vec![Some(1)])]);
+    let values: ArrayRef = Arc::new(Int32Array::new_null(0));
+    assert!(transform_list(&input, &values, true).is_err());
+}
+
+#[test]
+fn transform_ignores_values_past_the_elements() {
+    let input = list(&[Some(vec![Some(1), Some(2)])]);
+    let values: ArrayRef = Arc::new(Int32Array::from(vec![7, 8, 9]));
+    let out = transform_list(&input, &values, false).unwrap();
+    assert_eq!(rows(&out), vec![Some(vec![Some(7), Some(8)])]);
+    assert!(!out.value_field().is_nullable());
+}
+
+#[test]
+fn a_row_count_that_does_not_fit_is_an_internal_error() {
+    // No arguments: the interleaved length is the row count itself.
+    let err = create(&[], usize::MAX, false).unwrap_err();
+    assert!(err.to_string().contains(&usize::MAX.to_string()), "{err}");
+}
+
+#[test]
+fn filter_drops_unmarked_elements() {
+    // `[1, NULL, 3], NULL, [], [4]`, keeping the first of each pair.
+    let input = list(&[
+        Some(vec![Some(1), None, Some(3)]),
+        None,
+        Some(vec![]),
+        Some(vec![Some(4)]),
+    ]);
+    let keep = marks(vec![Some(true), None, Some(false), Some(true)]);
+    let out = filter_list(&input, &keep).unwrap();
+    assert_eq!(
+        rows(&out),
+        vec![Some(vec![Some(1)]), None, Some(vec![]), Some(vec![Some(4)]),]
+    );
+}
+
+#[test]
+fn filter_null_marks_drop() {
+    let input = list(&[Some(vec![Some(1), Some(2)])]);
+    let keep = marks(vec![None, None]);
+    let out = filter_list(&input, &keep).unwrap();
+    assert_eq!(rows(&out), vec![Some(vec![])]);
+}
+
+#[test]
+fn filter_rejects_short_marks() {
+    let input = list(&[Some(vec![Some(1), Some(2)])]);
+    assert!(filter_list(&input, &marks(vec![Some(true)])).is_err());
+}
+
+#[test]
+fn exists_folds_any_true() {
+    let input = list(&[
+        Some(vec![Some(1), None]),
+        Some(vec![None, None]),
+        None,
+        Some(vec![]),
+    ]);
+    // Row 0 has no true but a NULL: NULL. Row 1 only nulls: NULL.
+    let keep = marks(vec![Some(false), None, None, None]);
+    let out = exists_list(&input, &keep).unwrap();
+    let got: Vec<Option<bool>> = out.iter().collect();
+    assert_eq!(got, vec![None, None, None, Some(false)]);
+    let keep = marks(vec![Some(true), None, None, None]);
+    let out = exists_list(&input, &keep).unwrap();
+    let got: Vec<Option<bool>> = out.iter().collect();
+    assert_eq!(got, vec![Some(true), None, None, Some(false)]);
+}
+
+#[test]
+fn forall_folds_no_false() {
+    let input = list(&[
+        Some(vec![Some(1), None]),
+        Some(vec![None]),
+        None,
+        Some(vec![]),
+    ]);
+    // Row 0 has no false but a NULL: NULL. Row 1 only nulls: NULL.
+    let keep = marks(vec![Some(true), None, None]);
+    let out = forall_list(&input, &keep).unwrap();
+    let got: Vec<Option<bool>> = out.iter().collect();
+    assert_eq!(got, vec![None, None, None, Some(true)]);
+    let keep = marks(vec![Some(true), Some(false), None]);
+    let out = forall_list(&input, &keep).unwrap();
+    let got: Vec<Option<bool>> = out.iter().collect();
+    assert_eq!(got, vec![Some(false), None, None, Some(true)]);
+}
+
+#[test]
+fn fold_rejects_short_marks() {
+    let input = list(&[Some(vec![Some(1)])]);
+    let keep = marks(vec![]);
+    assert!(exists_list(&input, &keep).is_err());
+    assert!(forall_list(&input, &keep).is_err());
+}
+
+#[test]
+fn nested_lists_reshape() {
+    // `[[1, 2], [3]]`: filtering the single outer row's elements keeps
+    // whole inner lists, like any other element.
+    let inner = list(&[Some(vec![Some(1), Some(2)]), Some(vec![Some(3)])]);
+    let outer = ListArray::new(
+        Arc::new(Field::new("element", DataType::List(field()), true)),
+        OffsetBuffer::new(ScalarBuffer::from(vec![0, 2])),
+        Arc::new(inner),
+        None,
+    );
+    let keep = marks(vec![Some(false), Some(true)]);
+    let out = filter_list(&outer, &keep).unwrap();
+    assert_eq!(out.len(), 1);
+    assert_eq!(out.value_offsets(), &[0, 1]);
+    let kept: &ListArray = out.values().as_list::<i32>();
+    assert_eq!(kept.len(), 1);
+    assert_eq!(kept.value_offsets(), &[0, 1]);
+    assert_eq!(flat(kept), vec![Some(3)]);
+}
+
+#[test]
+fn large_offsets_reshape() {
+    // 100,000 single-element lists: the reshape is offset arithmetic.
+    // Miri interprets every element, so it checks a reduced case.
+    let n = if cfg!(miri) { 1_000usize } else { 100_000 };
+    let values: ArrayRef = Arc::new(Int32Array::from(vec![1; n]));
+    let input = ListArray::new(
+        field(),
+        OffsetBuffer::new(ScalarBuffer::from_iter(0..=i32::try_from(n).unwrap())),
+        values,
+        None,
+    );
+    let doubled: ArrayRef = Arc::new(Int32Array::from(vec![2; n]));
+    let out = transform_list(&input, &doubled, false).unwrap();
+    assert_eq!(out.len(), n);
+    assert_eq!(usize::try_from(out.value_offsets()[n]).unwrap(), n);
+    let keep = BooleanArray::from(vec![true; n]);
+    let out = filter_list(&input, &keep).unwrap();
+    assert_eq!(usize::try_from(out.value_offsets()[n]).unwrap(), n);
+    let out = exists_list(&input, &keep).unwrap();
+    assert!(out.iter().all(|v| v == Some(true)));
+    let out = forall_list(&input, &keep).unwrap();
+    assert!(out.iter().all(|v| v == Some(true)));
+}
diff --git a/crates/krishiv-kernels/src/reference.rs b/crates/krishiv-kernels/src/reference.rs
index 0350945aa..3ba1e58b1 100644
--- a/crates/krishiv-kernels/src/reference.rs
+++ b/crates/krishiv-kernels/src/reference.rs
@@ -518,6 +518,71 @@ where
     })
 }
 
+/// Reference for [`crate::list::create`]: one list per row holding each
+/// argument's value, built row-at-a-time over `Int32` arguments.
+///
+/// # Errors
+/// As the fast path.
+pub fn list_create(
+    args: &[arrow_array::ArrayRef],
+    rows: usize,
+    contains_null: bool,
+) -> Result<arrow_array::ListArray, KernelError> {
+    use arrow_array::cast::AsArray as _;
+    use arrow_array::types::Int32Type;
+    for a in args {
+        if a.len() != rows {
+            return Err(KernelError::internal(format!(
+                "array of {rows} rows over an argument of {} rows",
+                a.len()
+            )));
+        }
+    }
+    let len = rows
+        .checked_mul(args.len().max(1))
+        .ok_or_else(|| KernelError::internal(format!("a list of {rows} rows")))?;
+    if args.is_empty() {
+        let zeros = usize::checked_add(rows, 1)
+            .ok_or_else(|| KernelError::internal(format!("a list of {rows} rows")))?;
+        return Ok(arrow_array::ListArray::new(
+            std::sync::Arc::new(arrow_schema::Field::new(
+                "element",
+                arrow_schema::DataType::Null,
+                contains_null,
+            )),
+            arrow_buffer::OffsetBuffer::new(arrow_buffer::ScalarBuffer::from(vec![0_i32; zeros])),
+            std::sync::Arc::new(arrow_array::NullArray::new(0)),
+            None,
+        ));
+    }
+    let mut values: Vec<Option<i32>> = Vec::with_capacity(len);
+    let mut offsets = Vec::with_capacity(
+        len.checked_add(1)
+            .ok_or_else(|| KernelError::internal(format!("a list of {rows} rows")))?,
+    );
+    offsets.push(0_i32);
+    for r in 0..rows {
+        for a in args {
+            let col = a.as_primitive::<Int32Type>();
+            values.push(col.is_valid(r).then(|| col.value(r)));
+        }
+        offsets.push(
+            i32::try_from(values.len())
+                .map_err(|_| KernelError::internal(format!("a list of {rows} rows")))?,
+        );
+    }
+    Ok(arrow_array::ListArray::new(
+        std::sync::Arc::new(arrow_schema::Field::new(
+            "element",
+            arrow_schema::DataType::Int32,
+            contains_null,
+        )),
+        arrow_buffer::OffsetBuffer::new(arrow_buffer::ScalarBuffer::from(offsets)),
+        std::sync::Arc::new(arrow_array::Int32Array::from(values)),
+        None,
+    ))
+}
+
 #[cfg(test)]
 mod tests {
     use arrow_array::{Float32Array, Int64Array};
diff --git a/crates/krishiv-kernels/tests/props.rs b/crates/krishiv-kernels/tests/props.rs
index b312a95b2..f58d57889 100644
--- a/crates/krishiv-kernels/tests/props.rs
+++ b/crates/krishiv-kernels/tests/props.rs
@@ -1000,3 +1000,44 @@ fn check_bool(rows: &[(Option<bool>, Option<bool>)], scalar: Option<bool>) {
         assert_eq!(sca, flipped);
     }
 }
+
+proptest! {
+    #![proptest_config(config())]
+
+    /// `list::create` interleaves one list per row: the fast path equals
+    /// the row-at-a-time oracle, over sliced arguments with NULLs.
+    #[test]
+    fn list_create_matches_reference(
+        rows in 0..=200_usize,
+        nargs in 0..=3_usize,
+        contains_null in any::<bool>(),
+    ) {
+        use arrow_array::{ArrayRef, Int32Array};
+        use std::sync::Arc;
+        let mut args: Vec<ArrayRef> = Vec::new();
+        for c in 0..nargs {
+            let off = (c * 3 + rows) % 5;
+            let mut vals: Vec<Option<i32>> = (0..rows + off)
+                .map(|i| {
+                    let v = i32::try_from(i)
+                        .unwrap_or(i32::MAX)
+                        .wrapping_mul(7919 + i32::try_from(c).unwrap_or(i32::MAX))
+                        .wrapping_add(i32::try_from(rows).unwrap_or(i32::MAX));
+                    if (i + c) % 7 == 0 { None } else { Some(v) }
+                })
+                .collect();
+            if !contains_null {
+                for v in vals.iter_mut() {
+                    if v.is_none() {
+                        *v = Some(0);
+                    }
+                }
+            }
+            let full = Int32Array::from(vals);
+            args.push(Arc::new(full.slice(off, rows)) as ArrayRef);
+        }
+        let fast = krishiv_kernels::list::create(&args, rows, contains_null).unwrap();
+        let slow = reference::list_create(&args, rows, contains_null).unwrap();
+        assert_eq!(fast, slow);
+    }
+}
diff --git a/crates/krishiv-plan-codec/src/decode.rs b/crates/krishiv-plan-codec/src/decode.rs
index 126faf046..6954484f7 100644
--- a/crates/krishiv-plan-codec/src/decode.rs
+++ b/crates/krishiv-plan-codec/src/decode.rs
@@ -341,9 +341,11 @@ fn expr_children(m: &pb::Expr) -> impl Iterator<Item = u32> + '_ {
     let (one, many): (Option<u32>, &[u32]) = match &m.kind {
         Some(Kind::Cast(c)) => (Some(c.expr), &[]),
         Some(Kind::Alias(a)) => (Some(a.expr), &[]),
+        Some(Kind::Lambda(l)) => (Some(l.body), &[]),
         Some(Kind::Field(f)) => (Some(f.base), &[]),
         Some(Kind::Function(f)) => (f.filter, &f.args),
-        Some(Kind::Literal(_) | Kind::Column(_) | Kind::OuterColumn(_)) | None => (None, &[]),
+        Some(Kind::Literal(_) | Kind::Column(_) | Kind::OuterColumn(_) | Kind::LambdaVar(_))
+        | None => (None, &[]),
     };
     one.into_iter().chain(many.iter().copied())
 }
@@ -650,6 +652,11 @@ impl Decoder {
             Kind::Literal(l) => ExprNode::Literal(literal(l)?),
             Kind::Column(c) => ExprNode::Resolved(ResolvedExpr::Column(bound_column(c)?)),
             Kind::OuterColumn(c) => ExprNode::Resolved(ResolvedExpr::OuterColumn(bound_column(c)?)),
+            Kind::LambdaVar(c) => ExprNode::Resolved(ResolvedExpr::LambdaVar(bound_column(c)?)),
+            Kind::Lambda(l) => ExprNode::Lambda {
+                params: l.params.iter().map(bound_column).collect::<Result<_>>()?,
+                body: self.expr_ref(l.body)?,
+            },
             Kind::Cast(c) => ExprNode::Cast {
                 expr: self.expr_ref(c.expr)?,
                 to: spark_type(required(&c.to, "a cast type")?)?,
diff --git a/crates/krishiv-plan-codec/src/encode.rs b/crates/krishiv-plan-codec/src/encode.rs
index e8edec3ba..3684f3315 100644
--- a/crates/krishiv-plan-codec/src/encode.rs
+++ b/crates/krishiv-plan-codec/src/encode.rs
@@ -475,6 +475,16 @@ impl Encoder {
             ExprNode::Resolved(ResolvedExpr::OuterColumn(c)) => {
                 Kind::OuterColumn(bound_column(c, &self.nested)?)
             }
+            ExprNode::Lambda { params, body } => Kind::Lambda(pb::Lambda {
+                params: params
+                    .iter()
+                    .map(|p| bound_column(p, &self.nested))
+                    .collect::<Result<_>>()?,
+                body: self.child(body),
+            }),
+            ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => {
+                Kind::LambdaVar(bound_column(c, &self.nested)?)
+            }
             ExprNode::Resolved(ResolvedExpr::Function(f)) => Kind::Function(self.function(f)?),
             ExprNode::Resolved(ResolvedExpr::Alias { expr, output }) => {
                 Kind::Alias(pb::AliasExpr {
diff --git a/crates/krishiv-plan-codec/src/features.rs b/crates/krishiv-plan-codec/src/features.rs
index 6e06f58f0..ba93b5390 100644
--- a/crates/krishiv-plan-codec/src/features.rs
+++ b/crates/krishiv-plan-codec/src/features.rs
@@ -122,6 +122,7 @@ registry! {
     (join_build_preserved, JoinBuildPreserved, POST_MIGRATION_READER_VERSION, Optimization, "Joins that build their preserved side (`RightSemi`, `RightAnti`, `RightOuter`); without it the planner builds the other side (`LeftSemi`, `LeftAnti`, `LeftOuter`)."),
     (join_single_match, JoinSingleMatch, POST_MIGRATION_READER_VERSION, Semantic, "The single-match flag of a `LeftOuter` hash join (a scalar subquery: more than one match per probe row is an error)."),
     (key_group_hash, KeyGroupHash, POST_MIGRATION_READER_VERSION, Semantic, "Hash exchanges that route by key-group ranges of the routing hash `H_kg` version 1 (XXH64, seed 0, of the normalized key bytes, folded over several columns)."),
+    (lambda_functions, LambdaFunctions, POST_MIGRATION_READER_VERSION, Semantic, "Lambda expressions (`x -> body`) and variables: the bound bodies of higher-order function arguments (`transform`, `filter`, `exists`, `forall`)."),
     (legacy_statistical_aggregate, LegacyStatisticalAggregate, POST_MIGRATION_READER_VERSION, Semantic, "The `legacy_statistical_aggregate` expression environment flag (`spark.sql.legacy.statisticalAggregate`): the sample moment aggregates give NaN instead of NULL where Spark divides by zero."),
     (limit_offset, LimitOffset, 3, Semantic, "A `Limit` that skips leading rows (a nonzero offset)."),
     (nested_types, NestedTypes, POST_MIGRATION_READER_VERSION, Semantic, "Array, map and struct types (`DataType.KIND_NESTED`, written as Spark's JSON form of the type)."),
@@ -175,6 +176,9 @@ pub enum Construct<'a> {
     /// a subquery's value, a runtime filter's key, a window offset function's
     /// value, the plan's output schema).
     ArrowType(&'a arrow_schema::DataType),
+    /// A lambda expression or variable: the bound body of a higher-order
+    /// function's argument.
+    Lambda,
 }
 
 /// Whether an Arrow type is or contains an array, map or struct.
@@ -261,6 +265,9 @@ pub fn feature_of(construct: Construct<'_>) -> Option<Feature> {
                 Some(Feature::WindowOffsetFunctions)
             }
         },
+        // A lambda is plan data behind its own feature: a reader without
+        // it misreads the higher-order call's argument.
+        Construct::Lambda => Some(Feature::LambdaFunctions),
         // A type Krishiv does not know cannot be encoded at all. A later
         // feature for a type that can sit inside an array, map or struct
         // (variant, char/varchar, intervals) must look through them: its
@@ -355,6 +362,12 @@ fn constructs_of<'a>(node: &'a PhysNode, f: &mut impl FnMut(Construct<'a>)) {
         f(Construct::ArrowType(t));
     }
     for e in exprs_of(node) {
+        if matches!(
+            &e.node,
+            ExprNode::Lambda { .. } | ExprNode::Resolved(ResolvedExpr::LambdaVar(_))
+        ) {
+            f(Construct::Lambda);
+        }
         f(Construct::Expr(e));
     }
 }
@@ -405,7 +418,9 @@ fn types_of<'a>(node: &'a PhysNode) -> Vec<&'a DataType> {
         match &e.node {
             ExprNode::Cast { to, .. } => out.push(to),
             ExprNode::Literal(Literal::Null(Some(t))) => out.push(t),
-            ExprNode::Resolved(ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c)) => {
+            ExprNode::Resolved(
+                ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c) | ResolvedExpr::LambdaVar(c),
+            ) => {
                 out.push(&c.data_type);
             }
             ExprNode::Resolved(ResolvedExpr::Function(f)) => out.push(&f.data_type),
diff --git a/crates/krishiv-plan-codec/src/proto/krishiv.plan.v1.pb.rs b/crates/krishiv-plan-codec/src/proto/krishiv.plan.v1.pb.rs
index ab21b36d8..c5581730e 100644
--- a/crates/krishiv-plan-codec/src/proto/krishiv.plan.v1.pb.rs
+++ b/crates/krishiv-plan-codec/src/proto/krishiv.plan.v1.pb.rs
@@ -715,7 +715,7 @@ pub struct BoundColumn {
 pub struct Expr {
     #[prost(message, optional, tag = "1")]
     pub origin: ::core::option::Option<Origin>,
-    #[prost(oneof = "expr::Kind", tags = "2, 3, 4, 5, 6, 7, 8")]
+    #[prost(oneof = "expr::Kind", tags = "2, 3, 4, 5, 6, 7, 8, 9, 10")]
     pub kind: ::core::option::Option<expr::Kind>,
 }
 /// Nested message and enum types in `Expr`.
@@ -737,8 +737,24 @@ pub mod expr {
         /// feature: struct_field
         #[prost(message, tag = "8")]
         Field(super::FieldExpr),
+        /// feature: lambda_functions
+        #[prost(message, tag = "9")]
+        Lambda(super::Lambda),
+        /// feature: lambda_functions
+        #[prost(message, tag = "10")]
+        LambdaVar(super::BoundColumn),
     }
 }
+/// A lambda (`x -> body`): the bound body of a higher-order function's
+/// argument, with its variables as `lambda_var` leaves.
+/// feature: lambda_functions
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Lambda {
+    #[prost(message, repeated, tag = "1")]
+    pub params: ::prost::alloc::vec::Vec<BoundColumn>,
+    #[prost(uint32, tag = "2")]
+    pub body: u32,
+}
 #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct AliasExpr {
     #[prost(uint32, tag = "1")]
diff --git a/crates/krishiv-plan-codec/tests/common/inventory.rs b/crates/krishiv-plan-codec/tests/common/inventory.rs
index d5c48e19f..5b94f2305 100644
--- a/crates/krishiv-plan-codec/tests/common/inventory.rs
+++ b/crates/krishiv-plan-codec/tests/common/inventory.rs
@@ -910,6 +910,59 @@ pub(crate) fn expressions() -> PhysNode {
     }
 }
 
+/// Lambda expressions and variables: a `transform` over an array column
+/// (`transform(xs, x -> x * 2)`). The array type needs `nested_types` too.
+pub(crate) fn lambda_functions() -> PhysNode {
+    let t = |s: &str| parse_data_type(s).unwrap();
+    let array = t("array<int>");
+    let mut scan = scan();
+    if let PhysNode::Scan(s) = &mut scan {
+        s.scan.output.push(column(3, "xs", array.clone(), true));
+    }
+    let xs = col(3, "xs", array.clone());
+    let var = || {
+        Arc::new(Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(
+            column(11, "x", DataType::Integer, true),
+        ))))
+    };
+    let doubled = call(
+        Builtin::Multiply,
+        vec![var(), lit(Literal::Integer(2))],
+        DataType::Integer,
+    );
+    let transform = Arc::new(Expr::new(ExprNode::Resolved(ResolvedExpr::Function(
+        ResolvedFunction {
+            // The codec passes ids through; this is not the registry's.
+            id: FunctionId::Registry {
+                name: "transform".to_owned(),
+                id: 0,
+            },
+            kind: FunctionKind::Scalar,
+            args: vec![
+                xs,
+                Arc::new(Expr::new(ExprNode::Lambda {
+                    params: vec![column(11, "x", DataType::Integer, true)],
+                    body: doubled,
+                })),
+            ],
+            distinct: false,
+            filter: None,
+            data_type: array,
+            nullable: true,
+            deterministic: true,
+        },
+    ))));
+    PhysNode::Project {
+        input: boxed(scan),
+        layout: vec![AttrId(1), AttrId(2), AttrId(3)],
+        items: vec![ProjectItemPlan::Expr {
+            name: "doubled".to_owned(),
+            expr: transform,
+        }],
+        nullable: None,
+        subqueries: Vec::new(),
+    }
+}
 /// Array, map and struct types (depth 4, nullability, a comment) in a
 /// scan column, a cast, a typed NULL, a function and an alias.
 pub(crate) fn nested_types() -> PhysNode {
@@ -975,6 +1028,7 @@ pub(crate) fn cases() -> Vec<(String, PhysicalPlan)> {
         plan_of_env(PhysNode::OneRow, legacy),
     ));
     out.push(("nested_types".to_owned(), plan_of(nested_types())));
+    out.push(("lambda_functions".to_owned(), plan_of(lambda_functions())));
     out.push(("struct_field".to_owned(), plan_of(struct_field())));
     out
 }
diff --git a/crates/krishiv-plan-codec/tests/features.rs b/crates/krishiv-plan-codec/tests/features.rs
index 94bc11e08..7923b68dd 100644
--- a/crates/krishiv-plan-codec/tests/features.rs
+++ b/crates/krishiv-plan-codec/tests/features.rs
@@ -34,6 +34,11 @@ fn the_header_lists_exactly_the_features_in_use() {
     assert_eq!(m.epoch, EPOCH);
     assert_eq!(message("limit_offset").features, ["limit_offset"]);
     assert!(message("limit").features.is_empty());
+    // A lambda over arrays needs both features.
+    assert_eq!(
+        message("lambda_functions").features,
+        ["lambda_functions", "nested_types"]
+    );
     assert_eq!(
         message("window_frames").features,
         ["window", "window_frame_offsets"]
@@ -214,6 +219,11 @@ fn constructs_map_to_one_feature_or_the_baseline() {
         feature_of(Construct::Node(window.root())),
         Some(Feature::Window)
     );
+    assert_eq!(
+        feature_of(Construct::Lambda),
+        Some(Feature::LambdaFunctions)
+    );
+    assert_eq!(Feature::LambdaFunctions.kind(), FeatureKind::Semantic);
     assert_eq!(feature_of(Construct::Node(&PhysNode::OneRow)), None);
     let null_of = krishiv_exec::physical::ProjectItemPlan::NullOf {
         index: 0,
@@ -377,6 +387,24 @@ fn a_reader_without_a_feature_refuses_the_plan_naming_it() {
         }
     );
     assert_eq!(ReaderFeatures::default(), ReaderFeatures::all());
+    // A reader without `lambda_functions` refuses the lambda plan naming
+    // the feature, even though it knows `nested_types`.
+    let bytes = encode(
+        &cases()
+            .into_iter()
+            .find(|(n, _)| n == "lambda_functions")
+            .unwrap()
+            .1,
+    )
+    .unwrap();
+    let reader = ReaderFeatures::only([Feature::NestedTypes]);
+    let err = decode_with(&bytes, &Limits::default(), &reader).unwrap_err();
+    assert_eq!(
+        err,
+        CodecError::UnsupportedFeatures {
+            missing: vec!["lambda_functions".to_owned()]
+        }
+    );
 }
 
 #[test]
diff --git a/crates/krishiv-plan-codec/tests/golden/lambda_functions/lambda_functions.bin b/crates/krishiv-plan-codec/tests/golden/lambda_functions/lambda_functions.bin
new file mode 100644
index 000000000..f352a0dfe
Binary files /dev/null and b/crates/krishiv-plan-codec/tests/golden/lambda_functions/lambda_functions.bin differ
diff --git a/crates/krishiv-plan-codec/tests/roundtrip.rs b/crates/krishiv-plan-codec/tests/roundtrip.rs
index 9b5132309..e4c1cf20c 100644
--- a/crates/krishiv-plan-codec/tests/roundtrip.rs
+++ b/crates/krishiv-plan-codec/tests/roundtrip.rs
@@ -293,7 +293,7 @@ fn readers_that_predate_features_still_refuse_what_they_cannot_read() {
             "window_ranking" | "window_aggregates" => 4,
             n if n.starts_with("expand") => 5,
             // A feature added after the freeze: above every frozen version.
-            "window_group_limit" | "nested_types" | "struct_field" => 6,
+            "window_group_limit" | "nested_types" | "struct_field" | "lambda_functions" => 6,
             n if n.starts_with("hash_join_right") => POST_MIGRATION_READER_VERSION,
             "hash_join_existence"
             | "hash_join_single_match"
diff --git a/crates/krishiv-plan/src/analyzer/exprs.rs b/crates/krishiv-plan/src/analyzer/exprs.rs
index e7f39a289..d91c8a87a 100644
--- a/crates/krishiv-plan/src/analyzer/exprs.rs
+++ b/crates/krishiv-plan/src/analyzer/exprs.rs
@@ -15,13 +15,15 @@ use krishiv_common::error::{
     DatatypeMismatchInvalidOrderingType, DatatypeMismatchNonFoldableInput,
     DatatypeMismatchUnexpectedInputType, DuplicateRoutineParameterAssignmentBothPositionalAndNamed,
     DuplicateRoutineParameterAssignmentDoubleNamedArgumentReference, ExceptOverlappingColumns,
-    InternalError, InvalidAggregateFilterNotBoolean, InvalidExtractBaseFieldType,
+    FailedToParseTooComplex, InternalError, InvalidAggregateFilterNotBoolean,
+    InvalidExtractBaseFieldType,
     InvalidSubqueryExpressionScalarSubqueryReturnMoreThanOneOutputColumn,
     InvalidUsageOfStarOrRegex, KrishivError, KrishivUnsupportedFeature,
     NamedParametersNotSupported, NestedAggregateFunction, RequiredParameterNotFound,
     UnexpectedPositionalArgument, UnrecognizedParameterName, UnresolvedColumnWithSuggestion,
     UnresolvedColumnWithoutSuggestion, UnresolvedRoutine, WrongNumArgsWithoutSuggestion,
 };
+use krishiv_common::stack::on_big_stack;
 use krishiv_types::DataType;
 use twox_hash::XxHash3_128;
 
@@ -31,7 +33,7 @@ use super::builtins::{NamedDefault, NamedParam, named_signature};
 use super::catalog::quoted;
 use super::coerce::{self, Arg, BadCast, Mismatch, ordinal, quoted_type};
 use super::fold;
-use super::resolve::{Attr, Env, Rel, Resolver};
+use super::resolve::{Attr, Env, RESOLVE_STEP, Rel, Resolver};
 use super::suggest::closest;
 use super::{AnalysisError, ArgType, CallTypes, Constant, FunctionEntry, FunctionLookup, Inputs};
 use crate::{
@@ -595,9 +597,9 @@ fn is_special(value: &str) -> bool {
 /// `sum(x)` in `sum(x) OVER w` is a window aggregate, not an aggregate of
 /// the operator).
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
-struct Ctx {
-    agg: bool,
-    window_fn: bool,
+pub(super) struct Ctx {
+    pub(super) agg: bool,
+    pub(super) window_fn: bool,
 }
 
 enum Step {
@@ -611,14 +613,46 @@ impl Resolver<'_> {
     /// Binds `e` in `cx`, post-order with an explicit stack; a node shared
     /// within the expression is bound once.
     pub(super) fn expr(&mut self, e: &Arc<Expr>, cx: &Cx<'_>) -> Result<Bound, AnalysisError> {
-        let mut done: HashMap<(usize, Ctx), Bound> = HashMap::new();
-        // Rewritten calls stay alive for the pass: `done` is keyed by
-        // address.
-        let mut rewritten_calls: Vec<Arc<Expr>> = Vec::new();
         let top = Ctx {
             agg: false,
             window_fn: false,
         };
+        self.expr_in(top, e, cx)
+    }
+
+    /// Binds `e` in `cx` under the step context `top` (see [`Self::expr`]).
+    /// Higher-order calls bind their children through this with each
+    /// child's own context, so names inside lambdas resolve as the generic
+    /// path would resolve them. Every [`RESOLVE_STEP`] levels of
+    /// higher-order nesting run on a fresh stack (see [`Resolver::rel`).
+    pub(super) fn expr_in(
+        &mut self,
+        top: Ctx,
+        e: &Arc<Expr>,
+        cx: &Cx<'_>,
+    ) -> Result<Bound, AnalysisError> {
+        self.expr_depth += 1;
+        let r = if self.expr_depth.is_multiple_of(RESOLVE_STEP) {
+            on_big_stack(|| self.expr_in_on_stack(top, e, cx))
+                .unwrap_or_else(|| Err(AnalysisError::new(FailedToParseTooComplex {}, e.origin)))
+        } else {
+            self.expr_in_on_stack(top, e, cx)
+        };
+        self.expr_depth -= 1;
+        r
+    }
+
+    /// [`Self::expr_in`] on the current stack.
+    fn expr_in_on_stack(
+        &mut self,
+        top: Ctx,
+        e: &Arc<Expr>,
+        cx: &Cx<'_>,
+    ) -> Result<Bound, AnalysisError> {
+        let mut done: HashMap<(usize, Ctx), Bound> = HashMap::new();
+        // Rewritten calls stay alive for the pass: `done` is keyed by
+        // address.
+        let mut rewritten_calls: Vec<Arc<Expr>> = Vec::new();
         let mut stack = vec![Step::Enter(Arc::clone(e), top)];
         while let Some(step) = stack.pop() {
             match step {
@@ -632,6 +666,36 @@ impl Resolver<'_> {
                         stack.push(Step::Enter(rewritten, ctx));
                         continue;
                     }
+                    // A lambda binds where it is used: a higher-order
+                    // call binds its array and lambda children itself
+                    // (see `hof`), while a lambda anywhere else is no
+                    // higher-order call's argument.
+                    if let ExprNode::Function(f) = &x.node
+                        && (super::hof::Hof::of(&f.name).is_some()
+                            || super::hof::has_direct_lambda(f))
+                    {
+                        let Some(h) = super::hof::Hof::of(&f.name) else {
+                            return Err(super::hof::not_higher_order(&f.name, x.origin));
+                        };
+                        let kids = self.child_ctx(&x, ctx);
+                        for (key, bound) in self.hof_children(f, h, &kids, cx, x.origin)? {
+                            let step = kids
+                                .iter()
+                                .find(|(c, _)| addr(&**c) == key)
+                                .map(|(_, k)| *k)
+                                .unwrap_or(ctx);
+                            done.insert((key, step), bound);
+                        }
+                        stack.push(Step::Exit(Arc::clone(&x), ctx));
+                        let lambda = addr(&*f.args[1]);
+                        stack.extend(
+                            kids.into_iter()
+                                .rev()
+                                .filter(|(c, _)| addr(&**c) != lambda)
+                                .map(|(c, k)| Step::Enter(c, k)),
+                        );
+                        continue;
+                    }
                     stack.push(Step::Exit(Arc::clone(&x), ctx));
                     let kids = self.child_ctx(&x, ctx);
                     stack.extend(kids.into_iter().rev().map(|(c, k)| Step::Enter(c, k)));
@@ -1097,6 +1161,30 @@ impl Resolver<'_> {
                     e.origin,
                 ));
             }
+            // A lambda outside a higher-order function's argument list:
+            // lambdas in argument position are bound by the higher-order
+            // call itself (see `hof`), never here. An already-bound lambda
+            // (re-analysis of a resolved plan) is preserved as-is; its body
+            // already holds `LambdaVar` leaves.
+            ExprNode::Lambda { body, .. } => {
+                let bound = crate::walk::visit_distinct(crate::walk::Node::Expr(body), |n| {
+                    if let crate::walk::Node::Expr(x) = n
+                        && matches!(&x.node, ExprNode::Resolved(ResolvedExpr::LambdaVar(_)))
+                    {
+                        return std::ops::ControlFlow::Break(());
+                    }
+                    std::ops::ControlFlow::Continue(())
+                })
+                .is_break();
+                if bound && let Some(kid) = kids.first() {
+                    keep(kid.ty.clone())
+                } else {
+                    return Err(unsupported(
+                        "lambda functions outside a higher-order function",
+                        e.origin,
+                    ));
+                }
+            }
             ExprNode::Field { base: _, name } => {
                 let b = &kids[0];
                 let st = match &b.ty.data_type {
@@ -1434,7 +1522,13 @@ impl Resolver<'_> {
             }
             ExprNode::Subquery { kind, plan } => {
                 let env = self.sub_env(cx);
-                let rel = self.rel(plan, &env)?;
+                // A subquery resolves without the enclosing lambda scopes:
+                // its columns must not bind to enclosing lambda variables.
+                let saved = std::mem::take(&mut self.lambdas);
+                let rel = self.rel(plan, &env);
+                let stale = std::mem::replace(&mut self.lambdas, saved);
+                debug_assert!(stale.is_empty(), "a subquery leaks lambda scopes");
+                let rel = rel?;
                 let (data_type, nullable) = match kind {
                     SubqueryKind::Scalar => {
                         if rel.out.len() != 1 {
@@ -1477,15 +1571,18 @@ impl Resolver<'_> {
                 }
             }
             ExprNode::Window(w) => self.window(e, w, kids, cx)?,
-            ExprNode::Resolved(r) => keep(match r {
-                ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c) => column(c),
-                ResolvedExpr::Alias { output, .. } => column(output),
-                ResolvedExpr::Function(f) => arg_type(f.data_type.clone(), f.nullable),
-                ResolvedExpr::Field {
-                    data_type,
-                    nullable,
-                    ..
-                } => arg_type(data_type.clone(), *nullable),
+            ExprNode::Resolved(r) => keep({
+                use ResolvedExpr::{Column, LambdaVar, OuterColumn};
+                match r {
+                    Column(c) | OuterColumn(c) | LambdaVar(c) => column(c),
+                    ResolvedExpr::Alias { output, .. } => column(output),
+                    ResolvedExpr::Function(f) => arg_type(f.data_type.clone(), f.nullable),
+                    ResolvedExpr::Field {
+                        data_type,
+                        nullable,
+                        ..
+                    } => arg_type(data_type.clone(), *nullable),
+                }
             }),
         };
         if b.shown.is_none() && kids.iter().any(|k| k.shown.is_some()) {
@@ -2761,6 +2858,19 @@ impl Resolver<'_> {
             col.name.clone_from(&parts[used - 1]);
             col
         };
+        if c.plan_id.is_none()
+            && let [name] = &c.name[..]
+            && let Some(var) = self.lambda_var(name)
+        {
+            // A lambda variable shadows the enclosing query's columns.
+            let mut col = var;
+            col.name.clone_from(name);
+            return Ok(bound(
+                ExprNode::Resolved(ResolvedExpr::LambdaVar(col.clone())),
+                &col,
+                None,
+            ));
+        }
         if let Some(id) = c.plan_id {
             let a = self.plan_column(id, &c.name, cx, origin)?;
             self.used(&a);
@@ -3500,6 +3610,14 @@ fn pretty_node(x: &Expr, k: &[&str], zone: Option<i32>) -> String {
             }
         }
         ExprNode::Star(_) => "*".to_owned(),
+        // Spark's `lambdafunction(body, arg1, ...)`: the variables render
+        // as `namedlambdavariable()` when hidden (see `hof`).
+        ExprNode::Lambda { params, .. } => {
+            let mut args = vec![k[0].to_owned()];
+            args.extend(params.iter().map(|p| p.name.clone()));
+            format!("lambdafunction({})", args.join(", "))
+        }
+        ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => c.name.clone(),
         ExprNode::Window(w) => pretty_window(w, k, zone),
         ExprNode::Function(FunctionCall {
             name,
@@ -4118,6 +4236,38 @@ const fn frame_shape(b: &crate::FrameBound) -> u8 {
 mod tests {
     use super::*;
 
+    /// `lambdafunction(body, arg1, ...)`: a resolved lambda variable
+    /// prints as its name, like Spark's `NamedLambdaVariable`.
+    #[test]
+    fn lambdas_print_as_sparks_lambdafunction() {
+        let var = BoundColumn {
+            id: AttrId(9),
+            name: "y".to_owned(),
+            data_type: DataType::Integer,
+            nullable: false,
+        };
+        let body = Arc::new(Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(
+            var.clone(),
+        ))));
+        assert_eq!(pretty(&body, None), "y");
+        let lam = Expr::new(ExprNode::Lambda {
+            params: vec![var],
+            body,
+        });
+        assert_eq!(pretty(&lam, None), "lambdafunction(y, y)");
+    }
+
+    /// `*` prints as itself (the arm beside the lambda printers).
+    #[test]
+    fn stars_print_as_sql() {
+        let star = Expr::new(ExprNode::Star(crate::Star {
+            qualifier: Vec::new(),
+            except: Vec::new(),
+            plan_id: None,
+        }));
+        assert_eq!(pretty(&star, None), "*");
+    }
+
     /// `call()` renders named arguments with their `name => ` prefixes and
     /// quantified forms in their SQL shape.
     #[test]
diff --git a/crates/krishiv-plan/src/analyzer/hof.rs b/crates/krishiv-plan/src/analyzer/hof.rs
new file mode 100644
index 000000000..386e6c75f
--- /dev/null
+++ b/crates/krishiv-plan/src/analyzer/hof.rs
@@ -0,0 +1,317 @@
+// SPDX-License-Identifier: Apache-2.0
+//! Higher-order functions over arrays: `transform`, `filter`, `exists` and
+//! `forall` (Spark's `ArrayHigherOrderFunction`s with lambda bodies).
+//!
+//! A lambda (`x -> body`) is bound where it is used: the higher-order call
+//! binds its array argument first, pushes the lambda variables (typed with
+//! the array's element type) for the body, then pops them (Spark's
+//! `NamedLambdaVariable`). The variables shadow the enclosing query's
+//! columns, innermost lambda first, case-sensitively per the session.
+//!
+//! An argument that is not a lambda is a constant lambda: the body is the
+//! argument itself over hidden variables, as Spark analyzes
+//! `transform(arr, 42)` to `[42, 42, 42]` and rejects `filter(arr, 1)` with
+//! `DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE` quoting
+//! `lambdafunction(1, namedlambdavariable())`. The wrapped node carries the
+//! hidden variables so names and errors render as Spark's.
+//!
+//! The call itself is typed by the generic path once its children are
+//! bound: the lambda child's type is its body's, and the registry's result
+//! rules (see `krishiv-functions`) check the array and body types.
+
+use std::sync::Arc;
+
+use krishiv_common::error::{
+    InvalidLambdaFunctionCallDuplicateArgNames, InvalidLambdaFunctionCallNonHigherOrderFunction,
+    InvalidLambdaFunctionCallNumArgsMismatch, WrongNumArgsWithoutSuggestion,
+};
+use krishiv_types::{ArrayType, DataType};
+
+use super::AnalysisError;
+use super::bind::{addr, same, unsupported};
+use super::catalog::ArgType;
+use super::exprs::{Bound, Ctx, Cx, SPARK_DOC_ROOT};
+use super::resolve::Resolver;
+use crate::{BoundColumn, Expr, ExprNode, FunctionCall, Origin};
+
+/// One pushed lambda scope: its variables, innermost last.
+#[derive(Debug, Clone, Default)]
+pub(super) struct LambdaFrame {
+    /// The variables, in parameter order.
+    pub(super) vars: Vec<BoundColumn>,
+}
+
+/// A higher-order function over arrays.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum Hof {
+    /// `transform(arr, x -> ...)` or `transform(arr, (x, i) -> ...)`.
+    Transform,
+    /// `filter(arr, x -> ...)`.
+    Filter,
+    /// `exists(arr, x -> ...)`.
+    Exists,
+    /// `forall(arr, x -> ...)`.
+    ForAll,
+}
+
+impl Hof {
+    /// The higher-order function `name` calls, if one (ASCII
+    /// case-insensitive, as function names are).
+    #[must_use]
+    pub(super) fn of(name: &str) -> Option<Self> {
+        Some(match name.to_ascii_lowercase().as_str() {
+            "transform" => Self::Transform,
+            "filter" => Self::Filter,
+            "exists" => Self::Exists,
+            "forall" => Self::ForAll,
+            _ => return None,
+        })
+    }
+
+    /// The name, lower case (as the registry lists it).
+    const fn name(self) -> &'static str {
+        match self {
+            Self::Transform => "transform",
+            Self::Filter => "filter",
+            Self::Exists => "exists",
+            Self::ForAll => "forall",
+        }
+    }
+
+    /// The argument holding the array.
+    const fn array(self) -> usize {
+        0
+    }
+
+    /// The argument holding the lambda.
+    const fn lambda(self) -> usize {
+        1
+    }
+
+    /// The lambda's parameter counts `(min, max)`.
+    const fn params(self) -> (usize, usize) {
+        match self {
+            // The index is the optional second variable.
+            Self::Transform => (1, 2),
+            Self::Filter | Self::Exists | Self::ForAll => (1, 1),
+        }
+    }
+
+    /// The display of `expectedNumArgs` for a lambda of the wrong shape.
+    const fn expected_params(self) -> &'static str {
+        match self {
+            Self::Transform => "1 to 2",
+            Self::Filter | Self::Exists | Self::ForAll => "1",
+        }
+    }
+}
+
+/// Whether `f` takes a lambda as a direct argument: only a higher-order
+/// call may.
+pub(super) fn has_direct_lambda(f: &FunctionCall) -> bool {
+    f.args
+        .iter()
+        .any(|a| matches!(a.node, ExprNode::Lambda { .. }))
+}
+
+/// The error for a lambda in `name`'s argument list when `name` is no
+/// higher-order function (Spark's `INVALID_LAMBDA_FUNCTION_CALL` names the
+/// enclosing expression's class).
+pub(super) fn not_higher_order(name: &str, origin: Origin) -> AnalysisError {
+    AnalysisError::new(
+        InvalidLambdaFunctionCallNonHigherOrderFunction {
+            class: catalyst_class(name),
+        },
+        origin,
+    )
+}
+
+/// The Catalyst class Spark's message names for a function called with a
+/// lambda. Pinned by the goldens for `upper` and `ceil`; anything else is
+/// the usual class shape (`Upper` for `upper`), which is best-effort.
+fn catalyst_class(name: &str) -> String {
+    if name.eq_ignore_ascii_case("ceil") || name.eq_ignore_ascii_case("ceiling") {
+        return "org.apache.spark.sql.catalyst.expressions.CeilExpressionBuilder$".to_owned();
+    }
+    let mut class = name.to_ascii_lowercase();
+    if let Some(first) = class.get_mut(..1) {
+        first.make_ascii_uppercase();
+    }
+    format!("org.apache.spark.sql.catalyst.expressions.{class}")
+}
+
+impl Resolver<'_> {
+    /// The innermost lambda variable `name` names, if any.
+    pub(super) fn lambda_var(&self, name: &str) -> Option<BoundColumn> {
+        let cs = self.ctx.conf.case_sensitive;
+        self.lambdas
+            .iter()
+            .rev()
+            .flat_map(|f| f.vars.iter().rev())
+            .find(|v| same(&v.name, name, cs))
+            .cloned()
+    }
+
+    /// Binds the higher-order call's array child, then its lambda child:
+    /// the array first, so the lambda variables take its element type.
+    /// Returns each child with the address the generic path binds it under;
+    /// the caller records both and leaves the rest of the call to the
+    /// generic path.
+    ///
+    /// # Errors
+    /// A lambda error, as Spark reports it.
+    pub(super) fn hof_children(
+        &mut self,
+        f: &FunctionCall,
+        h: Hof,
+        kids: &[(Arc<Expr>, Ctx)],
+        cx: &Cx<'_>,
+        origin: Origin,
+    ) -> Result<[(usize, Bound); 2], AnalysisError> {
+        // Arity first, as Spark checks it: every function here takes the
+        // array and the lambda.
+        if f.args.len() != 2 {
+            return Err(AnalysisError::new(
+                WrongNumArgsWithoutSuggestion {
+                    function_name: format!("`{}`", h.name()),
+                    expected_num: "2".to_owned(),
+                    actual_num: f.args.len().to_string(),
+                    docroot: SPARK_DOC_ROOT.to_owned(),
+                },
+                origin,
+            ));
+        }
+        let at = |i: usize| {
+            kids.iter()
+                .find(|(c, _)| addr(&**c) == addr(&*f.args[i]))
+                .map(|(_, k)| *k)
+        };
+        let array_ctx = at(h.array()).unwrap_or(Ctx {
+            agg: false,
+            window_fn: false,
+        });
+        let lambda_ctx = at(h.lambda()).unwrap_or(array_ctx);
+        let array = self.expr_in(array_ctx, &f.args[h.array()], cx)?;
+        let lambda = self.hof_lambda(h, lambda_ctx, &array.ty, &f.args[h.lambda()], cx)?;
+        Ok([
+            (addr(&*f.args[h.array()]), array),
+            (addr(&*f.args[h.lambda()]), lambda),
+        ])
+    }
+
+    /// Binds the lambda `node` against `array_ty`: its variables, then its
+    /// body. A node that is no lambda is a constant lambda over one hidden
+    /// variable (see the module doc).
+    ///
+    /// # Errors
+    /// A lambda error, as Spark reports it.
+    fn hof_lambda(
+        &mut self,
+        h: Hof,
+        step: Ctx,
+        array_ty: &ArgType,
+        node: &Arc<Expr>,
+        cx: &Cx<'_>,
+    ) -> Result<Bound, AnalysisError> {
+        let hidden = !matches!(node.node, ExprNode::Lambda { .. });
+        let (params, inner) = match &node.node {
+            ExprNode::Lambda { params, body } => (
+                params.iter().map(|p| p.name.clone()).collect::<Vec<_>>(),
+                Arc::clone(body),
+            ),
+            // A constant lambda: the argument is the body.
+            _ => (vec!["namedlambdavariable()".to_owned()], Arc::clone(node)),
+        };
+        let (min, max) = h.params();
+        if params.len() < min || params.len() > max {
+            return Err(AnalysisError::new(
+                InvalidLambdaFunctionCallNumArgsMismatch {
+                    expected_num_args: h.expected_params().to_owned(),
+                    actual_num_args: params.len().to_string(),
+                },
+                node.origin,
+            ));
+        }
+        if !hidden && let Some(dup) = duplicate_param(&params, self.ctx.conf.case_sensitive) {
+            return Err(AnalysisError::new(
+                InvalidLambdaFunctionCallDuplicateArgNames {
+                    args: format!("[{}]", dup.join(", ")),
+                    case_sensitive_config: format!(
+                        "spark.sql.caseSensitive is set to {}",
+                        self.ctx.conf.case_sensitive
+                    ),
+                },
+                node.origin,
+            ));
+        }
+        // The element type, or `NULL` when the array check fails: the
+        // result rule reports the array, so the lambda still binds (names
+        // resolve before types, as in Spark).
+        let element = match &array_ty.data_type {
+            Some(DataType::Array(element)) => element.as_ref().clone(),
+            _ => ArrayType::new(DataType::Null, true),
+        };
+        let mut vars = vec![BoundColumn {
+            id: self.fresh(),
+            name: params[0].clone(),
+            data_type: element.element_type().clone(),
+            nullable: element.contains_null(),
+        }];
+        if params.len() == 2 {
+            vars.push(BoundColumn {
+                id: self.fresh(),
+                name: params[1].clone(),
+                data_type: DataType::Integer,
+                nullable: false,
+            });
+        }
+        self.lambdas.push(LambdaFrame { vars: vars.clone() });
+        let body = self.expr_in(step, &inner, cx);
+        self.lambdas.pop();
+        let body = body?;
+        // An aggregate or window over the lambda's elements is no outer
+        // query aggregate: a constant lambda's own aggregates stay outer
+        // aggregates, as the generic path resolves them.
+        if !hidden && body.agg.is_some() {
+            return Err(unsupported(
+                "aggregate functions in lambda functions",
+                node.origin,
+            ));
+        }
+        if !hidden && body.win.is_some() {
+            return Err(unsupported(
+                "window functions in lambda functions",
+                node.origin,
+            ));
+        }
+        let ty = body.ty.clone();
+        Ok(Bound {
+            expr: Arc::new(
+                Expr::new(ExprNode::Lambda {
+                    params: vars,
+                    body: Arc::clone(&body.expr),
+                })
+                .with_origin(node.origin),
+            ),
+            ty,
+            agg: hidden.then_some(body.agg).flatten(),
+            win: hidden.then_some(body.win).flatten(),
+            outer: body.outer,
+            lateral: body.lateral,
+            shown: (!hidden).then(|| Arc::clone(node)),
+        })
+    }
+}
+
+/// The first parameter `params` repeats (case-sensitively per `cs`), if
+/// any.
+fn duplicate_param(params: &[String], cs: bool) -> Option<Vec<String>> {
+    for (i, a) in params.iter().enumerate() {
+        for b in &params[..i] {
+            if same(a, b, cs) {
+                return Some(vec![a.clone()]);
+            }
+        }
+    }
+    None
+}
diff --git a/crates/krishiv-plan/src/analyzer/mod.rs b/crates/krishiv-plan/src/analyzer/mod.rs
index 1c869dfc5..8233bd747 100644
--- a/crates/krishiv-plan/src/analyzer/mod.rs
+++ b/crates/krishiv-plan/src/analyzer/mod.rs
@@ -71,6 +71,7 @@ mod exprs;
 mod fold;
 mod fold_ops;
 mod hints;
+mod hof;
 mod ops;
 mod pivot;
 mod resolve;
diff --git a/crates/krishiv-plan/src/analyzer/resolve.rs b/crates/krishiv-plan/src/analyzer/resolve.rs
index 66a9d64b5..cae41c816 100644
--- a/crates/krishiv-plan/src/analyzer/resolve.rs
+++ b/crates/krishiv-plan/src/analyzer/resolve.rs
@@ -26,7 +26,7 @@ use crate::{
 /// levels on the caller's stack; deeper levels run on fresh 64 MiB
 /// segments. The test thread stays at 2 MiB, so deep plans are still proven
 /// to resolve on a small stack.
-const RESOLVE_STEP: usize = 16;
+pub(super) const RESOLVE_STEP: usize = 16;
 
 /// An attribute in scope: the column, its qualifier and, for a table
 /// column, the securable it belongs to and its catalog name.
@@ -130,7 +130,14 @@ pub(super) struct Resolver<'a> {
     /// input shares subtrees, so equal input keys give equal plans.
     canon: HashMap<usize, Arc<LogicalPlan>>,
     pub(super) columns: Vec<BTreeSet<String>>,
+    /// The lambda scopes pushed by the higher-order calls whose bodies
+    /// bind now, innermost last (see `hof`).
+    pub(super) lambdas: Vec<super::hof::LambdaFrame>,
     depth: usize,
+    /// Expression-binding recursion through higher-order calls (see
+    /// `exprs::expr_in`): every [`RESOLVE_STEP`] levels run on a fresh
+    /// stack.
+    pub(super) expr_depth: usize,
     op_outer: Option<usize>,
     root_env: Option<Arc<Env>>,
     /// Constant folding's values over this pass (see `fold::Memo`).
@@ -159,9 +166,11 @@ pub(super) fn resolve(
         canon: HashMap::new(),
         columns: vec![BTreeSet::new(); b.securables.len()],
         depth: 0,
+        expr_depth: 0,
         op_outer: None,
         root_env: None,
         folds: std::cell::RefCell::default(),
+        lambdas: Vec::new(),
     };
     // Fresh ids start past every id the input already holds (a plan that
     // is resolved in part, or re-analysed).
@@ -207,11 +216,20 @@ fn first_free_id(root: &LogicalPlan) -> Result<u64, AnalysisError> {
                 if let ExprNode::Resolved(
                     ResolvedExpr::Column(c)
                     | ResolvedExpr::OuterColumn(c)
+                    | ResolvedExpr::LambdaVar(c)
                     | ResolvedExpr::Alias { output: c, .. },
                 ) = &e.node
                 {
                     bump(c);
                 }
+                if let ExprNode::Lambda { params, .. } = &e.node {
+                    // Unresolved lambdas carry placeholder identities (see
+                    // `Expr::lambda`); only bound variables reserve ids.
+                    params
+                        .iter()
+                        .filter(|c| c.id.0 != u64::MAX)
+                        .for_each(&mut bump);
+                }
             }
         }
         std::ops::ControlFlow::Continue(())
diff --git a/crates/krishiv-plan/src/display.rs b/crates/krishiv-plan/src/display.rs
index c4831de51..b3b03e52c 100644
--- a/crates/krishiv-plan/src/display.rs
+++ b/crates/krishiv-plan/src/display.rs
@@ -697,12 +697,17 @@ fn expr_pieces<'a>(e: &'a Expr, out: &mut Vec<Piece<'a>>) {
                 out.push(Piece::Str(") IN (list-query))"));
             }
         },
-        ExprNode::Resolved(ResolvedExpr::Column(c)) => {
+        ExprNode::Resolved(ResolvedExpr::Column(c) | ResolvedExpr::LambdaVar(c)) => {
             out.push(Piece::Owned(format!("{}#{}", c.name, c.id.0)));
         }
         ExprNode::Resolved(ResolvedExpr::OuterColumn(c)) => {
             out.push(Piece::Owned(format!("outer({}#{})", c.name, c.id.0)));
         }
+        ExprNode::Lambda { params, body } => {
+            let names: Vec<String> = params.iter().map(|p| p.name.clone()).collect();
+            out.push(Piece::Owned(format!("({}) -> ", names.join(", "))));
+            out.push(Piece::Expr(body));
+        }
         ExprNode::Resolved(ResolvedExpr::Alias { expr, output }) => {
             out.push(Piece::Expr(expr));
             out.push(Piece::Owned(format!(" AS {}#{}", output.name, output.id.0)));
diff --git a/crates/krishiv-plan/src/encode.rs b/crates/krishiv-plan/src/encode.rs
index cac567a45..3c6bba4e5 100644
--- a/crates/krishiv-plan/src/encode.rs
+++ b/crates/krishiv-plan/src/encode.rs
@@ -70,7 +70,7 @@ use crate::{
 };
 
 /// The version of the canonical encoding layout.
-pub const ENCODING_VERSION: u16 = 6;
+pub const ENCODING_VERSION: u16 = 7;
 
 /// A 128-bit structural key of a plan or subtree: XXH3-128 over the
 /// canonical encoding (see the module docs). Equal plans, ignoring origins,
@@ -1067,6 +1067,16 @@ impl<'k, 'a> Encoder<'k, 'a> {
                 self.bound(output);
                 self.expr(expr);
             }
+            ExprNode::Lambda { params, body } => {
+                self.u8(15);
+                self.len(params.len());
+                params.iter().for_each(|c| self.bound(c));
+                self.expr(body);
+            }
+            ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => {
+                self.u8(16);
+                self.bound(c);
+            }
             ExprNode::Window(crate::WindowExpr { function, window }) => {
                 self.u8(12);
                 self.expr(function);
diff --git a/crates/krishiv-plan/src/expr.rs b/crates/krishiv-plan/src/expr.rs
index dc1ebe242..816a6e803 100644
--- a/crates/krishiv-plan/src/expr.rs
+++ b/crates/krishiv-plan/src/expr.rs
@@ -67,6 +67,21 @@ pub enum ExprNode {
     Star(Star),
     /// An unresolved function call, operators included.
     Function(FunctionCall),
+    /// `x -> body` or `(x, y) -> body`: a lambda, bound by the analyzer
+    /// only as a direct argument of a higher-order function (`transform`,
+    /// `filter`, `exists`, `forall`, ...), where its variables take the
+    /// argument's element types (Spark's `NamedLambdaVariable`). The node
+    /// stays in place when bound: its `params` are then the variables
+    /// themselves (with stable [`AttrId`] identities), and its body holds
+    /// [`ResolvedExpr::LambdaVar`] leaves reading them.
+    Lambda {
+        /// The variables, in parameter order (with their stable identities
+        /// once bound; placeholders before).
+        params: Vec<BoundColumn>,
+        /// The body, resolved against the variables and the enclosing
+        /// query's columns.
+        body: Arc<Expr>,
+    },
     /// An unresolved `expr.field`: the field `name` of the struct `base`
     /// (Spark's `GetStructField`). A `Column` base lowers to a longer
     /// [`ColumnRef`] instead; anything else becomes this node.
@@ -391,6 +406,11 @@ pub enum ResolvedExpr {
     Column(BoundColumn),
     /// A column of an enclosing query, inside a correlated subquery.
     OuterColumn(BoundColumn),
+    /// A lambda variable, bound by the analyzer to one of the enclosing
+    /// [`ExprNode::Lambda`] node's parameters (Spark's
+    /// `NamedLambdaVariable`). It is not an output attribute: only the
+    /// higher-order function compiled around the lambda reads it.
+    LambdaVar(BoundColumn),
     /// A function bound to its identity and result type.
     Function(ResolvedFunction),
     /// The field `name` (position `ordinal`) of the struct `base` (Spark's
@@ -461,6 +481,25 @@ impl Expr {
         }))
     }
 
+    /// An unresolved `params -> body` lambda. Parameter identities are
+    /// placeholders (`AttrId(u64::MAX)`) until the analyzer binds them;
+    /// passes that reserve fresh ids (see `first_free_id`) skip them.
+    #[must_use]
+    pub fn lambda(params: Vec<String>, body: Self) -> Self {
+        Self::new(ExprNode::Lambda {
+            params: params
+                .into_iter()
+                .map(|name| BoundColumn {
+                    id: AttrId(u64::MAX),
+                    name,
+                    data_type: DataType::Null,
+                    nullable: true,
+                })
+                .collect(),
+            body: Arc::new(body),
+        })
+    }
+
     /// An unresolved call of a canonical operator.
     #[must_use]
     pub fn builtin(op: Builtin, args: Vec<Self>) -> Self {
@@ -510,7 +549,9 @@ impl Expr {
             | ExprNode::Literal(_)
             | ExprNode::TypedLiteral { .. }
             | ExprNode::Star(_)
-            | ExprNode::Resolved(ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_)) => {}
+            | ExprNode::Resolved(
+                ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_) | ResolvedExpr::LambdaVar(_),
+            ) => {}
             ExprNode::Function(FunctionCall { args, filter, .. })
             | ExprNode::Resolved(ResolvedExpr::Function(ResolvedFunction {
                 args, filter, ..
@@ -520,6 +561,7 @@ impl Expr {
             }
             ExprNode::Cast { expr, .. }
             | ExprNode::Alias { expr, .. }
+            | ExprNode::Lambda { body: expr, .. }
             | ExprNode::Field { base: expr, .. }
             | ExprNode::Resolved(
                 ResolvedExpr::Alias { expr, .. } | ResolvedExpr::Field { base: expr, .. },
@@ -553,7 +595,9 @@ impl Expr {
             | ExprNode::Literal(_)
             | ExprNode::TypedLiteral { .. }
             | ExprNode::Star(_)
-            | ExprNode::Resolved(ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_)) => {}
+            | ExprNode::Resolved(
+                ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_) | ResolvedExpr::LambdaVar(_),
+            ) => {}
             ExprNode::Function(FunctionCall { args, filter, .. })
             | ExprNode::Resolved(ResolvedExpr::Function(ResolvedFunction {
                 args, filter, ..
@@ -563,6 +607,7 @@ impl Expr {
             }
             ExprNode::Cast { expr, .. }
             | ExprNode::Alias { expr, .. }
+            | ExprNode::Lambda { body: expr, .. }
             | ExprNode::Field { base: expr, .. }
             | ExprNode::Resolved(
                 ResolvedExpr::Alias { expr, .. } | ResolvedExpr::Field { base: expr, .. },
diff --git a/crates/krishiv-plan/src/lib.rs b/crates/krishiv-plan/src/lib.rs
index ca65cc9ee..cf92b543d 100644
--- a/crates/krishiv-plan/src/lib.rs
+++ b/crates/krishiv-plan/src/lib.rs
@@ -96,9 +96,11 @@
 //! | `ExprNode::Field` | U | - | - |
 //! | `ExprNode::Subquery` | U, R | Q2, Q4, Q11, Q15-Q18, Q20-Q22 | - |
 //! | `ExprNode::Window` | U, R | - | - |
+//! | `ExprNode::Lambda` | U, R | - | - |
 //! | `ResolvedExpr::Column` | R | - | - |
 //! | `ResolvedExpr::OuterColumn` | R | - | - |
 //! | `ResolvedExpr::Function` | R | - | - |
+//! | `ResolvedExpr::LambdaVar` | R | - | - |
 //! | `ResolvedExpr::Alias` | R | - | - |
 //! | `ResolvedExpr::Field` | R | - | - |
 //!
diff --git a/crates/krishiv-plan/src/tests/encode.rs b/crates/krishiv-plan/src/tests/encode.rs
index 2a42f6eba..a8f9cde86 100644
--- a/crates/krishiv-plan/src/tests/encode.rs
+++ b/crates/krishiv-plan/src/tests/encode.rs
@@ -10,6 +10,7 @@ use krishiv_common::secret::OptionValue;
 use krishiv_types::DataType;
 
 use super::depth::self_joins;
+use crate::{AttrId, BoundColumn};
 use crate::{
     Builtin, ColumnRef, Expr, ExprNode, FunctionId, FunctionKind, JoinCondition, JoinKind, Literal,
     LogicalPlan, Origin, Plan, PlanId, PlanNode, ReadSource, ResolvedExpr, ResolvedFunction,
@@ -242,6 +243,60 @@ fn resolved_call(name: &str, id: u32, kind: FunctionKind, arg: &str) -> LogicalP
     LogicalPlan::table(["t"]).project(vec![call])
 }
 
+/// A lambda and its variables enter the key: parameter names, the
+/// variable's name and identity, and the lambda/variable tags all count.
+#[test]
+fn lambda_and_its_variables_enter_the_key() {
+    let var = BoundColumn {
+        id: AttrId(2),
+        name: "y".to_owned(),
+        data_type: DataType::Integer,
+        nullable: false,
+    };
+    let body = Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(var.clone())));
+    let lam = |params: Vec<BoundColumn>| {
+        Expr::new(ExprNode::Lambda {
+            params,
+            body: Arc::new(body.clone()),
+        })
+    };
+    let param = |name: &str| BoundColumn {
+        id: AttrId(2),
+        name: name.to_owned(),
+        data_type: DataType::Integer,
+        nullable: false,
+    };
+    let p = |e: Expr| key(LogicalPlan::table(["t"]).filter(e));
+    let base = p(lam(vec![param("y")]));
+    assert_ne!(p(lam(vec![param("z")])), base, "params");
+    let renamed = Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(BoundColumn {
+        id: AttrId(2),
+        name: "z".to_owned(),
+        data_type: DataType::Integer,
+        nullable: false,
+    })));
+    let renamed = Expr::new(ExprNode::Lambda {
+        params: vec![param("z")],
+        body: Arc::new(renamed),
+    });
+    assert_ne!(p(renamed), base, "variable name");
+    let reid = Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(BoundColumn {
+        id: AttrId(3),
+        ..var.clone()
+    })));
+    let reid = Expr::new(ExprNode::Lambda {
+        params: vec![BoundColumn {
+            id: AttrId(3),
+            ..param("y")
+        }],
+        body: Arc::new(reid),
+    });
+    assert_ne!(p(reid), base, "variable identity");
+    // A variable is not a column with the same name and identity.
+    let col = Expr::new(ExprNode::Resolved(ResolvedExpr::Column(var)));
+    assert_ne!(p(col), base, "variable tag");
+}
+
 /// A function's key is its name, kind and arguments, never its registry
 /// handle, so a cache shared across builds cannot confuse two functions.
 #[test]
@@ -290,7 +345,7 @@ fn keys_are_stable() {
         .project(vec![Expr::column(["a"]).alias("b")]);
     let (hash, encoding) = key(plan);
     assert_eq!(encoding.len(), 493, "{encoding:?}");
-    assert_eq!(hash.to_string(), "c52735ab283b4cec155d3ea789487c38");
+    assert_eq!(hash.to_string(), "eaeeb9e9da010966fde69769c8d36f0f");
     // Options other than inline secrets, whose keys are per process.
     let options = [
         ("header", OptionValue::Plain("true".to_owned())),
@@ -302,7 +357,7 @@ fn keys_are_stable() {
     }));
     let (hash, encoding) = key(read);
     assert_eq!(encoding.len(), 124, "{encoding:?}");
-    assert_eq!(hash.to_string(), "062cd8e7cfaceee9a9e908d776219685");
+    assert_eq!(hash.to_string(), "abc19dd01ab19870f695f43bf481168f");
 }
 
 /// A plan whose subtrees are shared (`p = p.join(p)` 30 times) is keyed in
diff --git a/crates/krishiv-plan/src/tests/inventory.rs b/crates/krishiv-plan/src/tests/inventory.rs
index 1966b4229..5884f988d 100644
--- a/crates/krishiv-plan/src/tests/inventory.rs
+++ b/crates/krishiv-plan/src/tests/inventory.rs
@@ -64,8 +64,10 @@ fn expr_kinds(expr: &Expr, out: &mut BTreeSet<&'static str>) {
         ExprNode::Alias { .. } => "ExprNode::Alias",
         ExprNode::Subquery { .. } => "ExprNode::Subquery",
         ExprNode::Window(_) => "ExprNode::Window",
+        ExprNode::Lambda { .. } => "ExprNode::Lambda",
         ExprNode::Resolved(ResolvedExpr::Column(_)) => "ResolvedExpr::Column",
         ExprNode::Resolved(ResolvedExpr::OuterColumn(_)) => "ResolvedExpr::OuterColumn",
+        ExprNode::Resolved(ResolvedExpr::LambdaVar(_)) => "ResolvedExpr::LambdaVar",
         ExprNode::Resolved(ResolvedExpr::Function(_)) => "ResolvedExpr::Function",
         ExprNode::Resolved(ResolvedExpr::Alias { .. }) => "ResolvedExpr::Alias",
         ExprNode::Resolved(ResolvedExpr::Field { .. }) => "ResolvedExpr::Field",
diff --git a/crates/krishiv-plan/src/tests/props.rs b/crates/krishiv-plan/src/tests/props.rs
index fefe677a2..812dce8b9 100644
--- a/crates/krishiv-plan/src/tests/props.rs
+++ b/crates/krishiv-plan/src/tests/props.rs
@@ -169,7 +169,7 @@ impl Gen<'_> {
 
     fn expr(&mut self, depth: u8) -> Expr {
         let origin = self.origin();
-        let kinds = if depth == 0 { 5 } else { 14 };
+        let kinds = if depth == 0 { 5 } else { 16 };
         let d = depth.saturating_sub(1);
         let node = match self.pick(kinds) {
             0 => ExprNode::Column(ColumnRef {
@@ -245,11 +245,15 @@ impl Gen<'_> {
                 expr: Arc::new(self.expr(d)),
                 output: self.bound(),
             }),
-            10 => ExprNode::Field {
+            10 => ExprNode::Lambda {
+                params: vec![self.bound()],
+                body: Arc::new(self.expr(d)),
+            },
+            13 => ExprNode::Field {
                 base: Arc::new(self.expr(d)),
                 name: self.name(),
             },
-            12 => ExprNode::Resolved(ResolvedExpr::Field {
+            14 => ExprNode::Resolved(ResolvedExpr::Field {
                 base: Arc::new(self.expr(d)),
                 ordinal: usize::from(self.pick(9)),
                 name: self.name(),
@@ -276,6 +280,7 @@ impl Gen<'_> {
                     })
                 },
             }),
+            12 => ExprNode::Resolved(ResolvedExpr::LambdaVar(self.bound())),
             _ => ExprNode::Subquery {
                 kind: match self.pick(3) {
                     0 => SubqueryKind::Scalar,
@@ -757,6 +762,18 @@ fn m_expr(e: &mut Arc<Expr>, w: &mut Walk) -> bool {
             m_type(to, w) || m_expr(expr, w)
         }
         ExprNode::Alias { expr, name } => m_string(name, w) || m_expr(expr, w),
+        ExprNode::Lambda { params, body } => {
+            site!(
+                w,
+                params.push(BoundColumn {
+                    id: AttrId(99),
+                    name: "x".to_owned(),
+                    data_type: DataType::Integer,
+                    nullable: false,
+                })
+            );
+            params.iter_mut().any(|p| m_bound(p, w)) || m_expr(body, w)
+        }
         ExprNode::Field { base, name } => m_string(name, w) || m_expr(base, w),
         ExprNode::Subquery { kind, plan } => {
             let other = match kind {
@@ -787,7 +804,9 @@ fn m_expr(e: &mut Arc<Expr>, w: &mut Walk) -> bool {
             inside || m_expr(function, w)
         }
         ExprNode::Resolved(r) => match r {
-            ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c) => m_bound(c, w),
+            ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c) | ResolvedExpr::LambdaVar(c) => {
+                m_bound(c, w)
+            }
             ResolvedExpr::Function(ResolvedFunction {
                 id,
                 kind,
diff --git a/crates/krishiv-plan/src/tests/rewrite.rs b/crates/krishiv-plan/src/tests/rewrite.rs
index 565d8c739..17b7a9cbc 100644
--- a/crates/krishiv-plan/src/tests/rewrite.rs
+++ b/crates/krishiv-plan/src/tests/rewrite.rs
@@ -273,6 +273,17 @@ fn exprs() -> Vec<(Expr, usize)> {
             Expr::new(ExprNode::Resolved(ResolvedExpr::OuterColumn(bound("a")))),
             0,
         ),
+        (
+            Expr::new(ExprNode::Lambda {
+                params: vec![bound("y")],
+                body: col("a"),
+            }),
+            1,
+        ),
+        (
+            Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(bound("a")))),
+            0,
+        ),
         (resolved_call(vec![col("a")], Some(col("b"))), 2),
         (
             Expr::new(ExprNode::Resolved(ResolvedExpr::Alias {
@@ -318,6 +329,21 @@ fn every_expression_slot_is_rewritten_in_order() {
     }
 }
 
+/// Leaves expose no slots: rewriting one visits nothing and changes nothing.
+#[test]
+fn leaves_have_no_slots_to_rewrite() {
+    for mut e in [
+        Expr::column(["a"]),
+        Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(bound("v")))),
+    ] {
+        let before = e.clone();
+        let mut visits = 0;
+        e.for_each_child_mut(&mut |_| visits += 1);
+        assert_eq!(visits, 0, "{e:?}");
+        assert_eq!(e, before);
+    }
+}
+
 #[test]
 fn expression_resolution() {
     let resolved = [
diff --git a/crates/krishiv-plan/src/walk.rs b/crates/krishiv-plan/src/walk.rs
index 13be63090..0d3c71c66 100644
--- a/crates/krishiv-plan/src/walk.rs
+++ b/crates/krishiv-plan/src/walk.rs
@@ -180,7 +180,12 @@ pub(crate) fn all_resolved(root: Node<'_>) -> bool {
                     &w.window,
                     crate::WindowSpecRef::Spec(crate::WindowSpec { frame: Some(_), .. })
                 ),
-                ExprNode::Literal(_) | ExprNode::Subquery { .. } | ExprNode::Resolved(_) => true,
+                // A lambda is resolved once its body is (visited on its
+                // own); its parameters are plain names.
+                ExprNode::Lambda { .. }
+                | ExprNode::Literal(_)
+                | ExprNode::Subquery { .. }
+                | ExprNode::Resolved(_) => true,
             },
         };
         if resolved {
@@ -372,7 +377,9 @@ impl Teardown {
             | ExprNode::Literal(_)
             | ExprNode::TypedLiteral { .. }
             | ExprNode::Star(_)
-            | ExprNode::Resolved(ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_)) => {}
+            | ExprNode::Resolved(
+                ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_) | ResolvedExpr::LambdaVar(_),
+            ) => {}
             ExprNode::Function(FunctionCall { args, filter, .. })
             | ExprNode::Resolved(ResolvedExpr::Function(ResolvedFunction {
                 args, filter, ..
@@ -382,6 +389,7 @@ impl Teardown {
             }
             ExprNode::Cast { expr, .. }
             | ExprNode::Alias { expr, .. }
+            | ExprNode::Lambda { body: expr, .. }
             | ExprNode::Field { base: expr, .. }
             | ExprNode::Resolved(
                 ResolvedExpr::Alias { expr, .. } | ResolvedExpr::Field { base: expr, .. },
diff --git a/crates/krishiv-session/tests/datetime_calendar.rs b/crates/krishiv-session/tests/datetime_calendar.rs
index 5291fbce5..b6d406768 100644
--- a/crates/krishiv-session/tests/datetime_calendar.rs
+++ b/crates/krishiv-session/tests/datetime_calendar.rs
@@ -291,7 +291,7 @@ fn matrix_cells_match_spark() {
     // instead of passing silently.
     assert_eq!(tally.not_run, expected_not_run(), "{report}");
     assert_eq!(tally.normalized_cast_invalid_input, 96, "{report}");
-    assert_eq!(tally.normalized_months_between, 44, "{report}");
+    assert_eq!(tally.normalized_months_between, 48, "{report}");
 }
 
 /// The exact cells the engine does not run: region time zones (no tz
@@ -302,7 +302,7 @@ fn expected_not_run() -> BTreeMap<String, usize> {
     BTreeMap::from([
         (
             "analysis errors of the rewritten convert_timezone".to_owned(),
-            24,
+            28,
         ),
         ("cast of invalid UTF-8 bytes to a string".to_owned(), 23),
         ("no recorded rows".to_owned(), 62),
@@ -311,7 +311,6 @@ fn expected_not_run() -> BTreeMap<String, usize> {
         ("unsupported: INTERVAL literals".to_owned(), 144),
         ("unsupported: TIME literals".to_owned(), 6),
         ("unsupported: function DATE".to_owned(), 4),
-        ("unsupported: function array".to_owned(), 74),
         ("unsupported: function map".to_owned(), 74),
         (
             "unsupported: the function convert_timezone (it has no binding for these arguments: a region time zone)"
diff --git a/crates/krishiv-session/tests/higher_order.rs b/crates/krishiv-session/tests/higher_order.rs
new file mode 100644
index 000000000..2f4a3ffd0
--- /dev/null
+++ b/crates/krishiv-session/tests/higher_order.rs
@@ -0,0 +1,597 @@
+// SPDX-License-Identifier: Apache-2.0
+//! Higher-order functions over arrays end to end: `transform`, `filter`,
+//! `exists` and `forall`, with the `array` constructor they need. Values,
+//! output names and error classes follow Spark 4.2's
+//! `higher-order-functions.sql` golden; the error texts of the
+//! constant-lambda mismatches match its `messageParameters` exactly.
+#![cfg(test)]
+
+use std::sync::Arc;
+
+use arrow_array::cast::AsArray;
+use arrow_array::{Array, ArrayRef, Int32Array, ListArray, RecordBatch};
+use arrow_buffer::{NullBuffer, OffsetBuffer, ScalarBuffer};
+use arrow_schema::{DataType as ArrowType, Field, Schema};
+use futures::executor::block_on;
+use krishiv_common::error::{ErrorClass, KrishivError};
+use krishiv_session::Session;
+use krishiv_types::{ArrayType, DataType};
+
+/// `t(ys array<int>, zs array<array<int>>, n int)`, five rows: two
+/// populated, `[12]`, a NULL row and an empty row.
+fn session() -> Session {
+    let s = Session::new().unwrap();
+    let element = Field::new("element", ArrowType::Int32, false);
+    let mut ys_builder =
+        arrow_array::builder::ListBuilder::new(arrow_array::builder::Int32Builder::new())
+            .with_field(Arc::new(element.clone()));
+    ys_builder.append_value([Some(32), Some(97)]);
+    ys_builder.append_value([Some(77), Some(-76)]);
+    ys_builder.append_value([Some(12)]);
+    ys_builder.append_null();
+    ys_builder.append_value([]);
+    let ys: ArrayRef = Arc::new(ys_builder.finish());
+    let inner: ArrayRef = Arc::new(ListArray::new(
+        Arc::new(element),
+        OffsetBuffer::new(ScalarBuffer::from(vec![0, 2, 3, 3, 4])),
+        Arc::new(Int32Array::from(vec![1, 2, 3, 4])),
+        None,
+    ));
+    let zs = ListArray::new(
+        Arc::new(Field::new(
+            "element",
+            ArrowType::List(Arc::new(Field::new("element", ArrowType::Int32, false))),
+            true,
+        )),
+        OffsetBuffer::new(ScalarBuffer::from(vec![0, 2, 2, 3, 3, 4])),
+        inner,
+        Some(NullBuffer::from(vec![true, false, true, false, true])),
+    );
+    let n: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5]));
+    let schema = Arc::new(Schema::new(vec![
+        Field::new("ys", ys.data_type().clone(), true),
+        Field::new("zs", zs.data_type().clone(), true),
+        Field::new("n", ArrowType::Int32, false),
+    ]));
+    let batch = RecordBatch::try_new(Arc::clone(&schema), vec![ys, Arc::new(zs), n]).unwrap();
+    s.register_batches("t", schema, vec![batch]).unwrap();
+    s
+}
+
+/// `SELECT CAST(<expr> AS STRING) [<from>]`: every row of the single
+/// column, `None` for NULL.
+fn strings(s: &Session, expr: &str, from: &str) -> Vec<Option<String>> {
+    let sql = format!("SELECT CAST({expr} AS STRING) {from}");
+    let df = block_on(s.sql(&sql)).unwrap_or_else(|e| panic!("{sql}: {e}"));
+    block_on(df.collect())
+        .unwrap_or_else(|e| panic!("{sql}: {e}"))
+        .iter()
+        .flat_map(|b| {
+            b.column(0)
+                .as_string_view()
+                .iter()
+                .map(|v| v.map(str::to_owned))
+                .collect::<Vec<_>>()
+        })
+        .collect()
+}
+
+fn error(s: &Session, sql: &str) -> KrishivError {
+    match block_on(s.sql(sql)) {
+        Ok(_) => panic!("{sql} resolved"),
+        Err(e) => e,
+    }
+}
+
+#[test]
+fn transform_maps_each_element() {
+    let s = session();
+    assert_eq!(
+        strings(&s, "transform(ys, y -> y * y)", "FROM t"),
+        [
+            Some("[1024, 9409]".to_owned()),
+            Some("[5929, 5776]".to_owned()),
+            Some("[144]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+    // A NULL array is NULL, whatever the body.
+    assert_eq!(
+        strings(&s, "transform(CAST(NULL AS ARRAY<INT>), x -> x + 1)", ""),
+        [None]
+    );
+    // A constant lambda repeats its body.
+    assert_eq!(
+        strings(&s, "transform(array(1, 2, 3), 42)", ""),
+        [Some("[42, 42, 42]".to_owned())]
+    );
+}
+
+#[test]
+fn transform_with_index_and_captures() {
+    let s = session();
+    // The index counts positions within each list.
+    assert_eq!(
+        strings(&s, "transform(ys, (y, i) -> y + i)", "FROM t"),
+        [
+            Some("[32, 98]".to_owned()),
+            Some("[77, -75]".to_owned()),
+            Some("[12]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+    // An outer column repeats per element.
+    assert_eq!(
+        strings(&s, "transform(ys, y -> y + n)", "FROM t"),
+        [
+            Some("[33, 98]".to_owned()),
+            Some("[79, -74]".to_owned()),
+            Some("[15]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+    // A lambda variable shadows an outer column of the same name.
+    assert_eq!(
+        strings(&s, "transform(ys, n -> n + 1)", "FROM t"),
+        [
+            Some("[33, 98]".to_owned()),
+            Some("[78, -75]".to_owned()),
+            Some("[13]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+}
+
+#[test]
+fn higher_order_functions_nest() {
+    let s = session();
+    assert_eq!(
+        strings(&s, "transform(zs, z -> filter(z, zz -> zz > 1))", "FROM t"),
+        [
+            Some("[[2], [3]]".to_owned()),
+            None,
+            Some("[[]]".to_owned()),
+            None,
+            Some("[[4]]".to_owned()),
+        ]
+    );
+}
+
+#[test]
+fn nested_lambdas_capture_enclosing_variables() {
+    let s = session();
+    // The inner body reads the outer call's element variable: every level
+    // carries what the levels below need.
+    assert_eq!(
+        strings(
+            &s,
+            "transform(ys, y -> transform(array(1, 2), z -> z + y))",
+            "FROM t"
+        ),
+        [
+            Some("[[33, 34], [98, 99]]".to_owned()),
+            Some("[[78, 79], [-75, -74]]".to_owned()),
+            Some("[[13, 14]]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+    // The inner body reads the outer call's index variable.
+    assert_eq!(
+        strings(
+            &s,
+            "transform(ys, (y, i) -> transform(array(10, 2 * 10), z -> z + i))",
+            "FROM t"
+        ),
+        [
+            Some("[[10, 20], [11, 21]]".to_owned()),
+            Some("[[10, 20], [11, 21]]".to_owned()),
+            Some("[[10, 20]]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+    // An outer column reaches through two levels, beside the element.
+    assert_eq!(
+        strings(
+            &s,
+            "transform(ys, y -> transform(array(1, 2), z -> z + y + n))",
+            "FROM t"
+        ),
+        [
+            Some("[[34, 35], [99, 100]]".to_owned()),
+            Some("[[80, 81], [-73, -72]]".to_owned()),
+            Some("[[16, 17]]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+    // Three levels: the middle call carries both its element and the outer
+    // call's element down to the innermost body.
+    assert_eq!(
+        strings(
+            &s,
+            "transform(ys, y -> transform(ys, z -> transform(array(1), w -> w + y + z)))",
+            "FROM t"
+        ),
+        [
+            Some("[[[65], [130]], [[130], [195]]]".to_owned()),
+            Some("[[[155], [2]], [[2], [-151]]]".to_owned()),
+            Some("[[[25]]]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+    // Shadowing still binds the innermost variable: the inner `y` is its
+    // own element, not the outer call's.
+    assert_eq!(
+        strings(
+            &s,
+            "transform(ys, y -> transform(array(100), y -> y + 1))",
+            "FROM t"
+        ),
+        [
+            Some("[[101], [101]]".to_owned()),
+            Some("[[101], [101]]".to_owned()),
+            Some("[[101]]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+}
+
+#[test]
+fn filter_keeps_true_elements() {
+    let s = session();
+    assert_eq!(
+        strings(&s, "filter(ys, y -> y > 30)", "FROM t"),
+        [
+            Some("[32, 97]".to_owned()),
+            Some("[77]".to_owned()),
+            Some("[]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+    // A NULL predicate drops its element; a NULL array is NULL.
+    assert_eq!(
+        strings(&s, "filter(array(1, NULL, 3), x -> x > 1)", ""),
+        [Some("[3]".to_owned())]
+    );
+    assert_eq!(
+        strings(&s, "filter(CAST(NULL AS ARRAY<INT>), y -> TRUE)", ""),
+        [None]
+    );
+    assert_eq!(
+        strings(&s, "filter(array(1, 2, 3), TRUE)", ""),
+        [Some("[1, 2, 3]".to_owned())]
+    );
+}
+
+#[test]
+fn exists_and_forall_fold_the_marks() {
+    let s = session();
+    assert_eq!(
+        strings(&s, "exists(ys, y -> y > 30)", "FROM t"),
+        [
+            Some("true".to_owned()),
+            Some("true".to_owned()),
+            Some("false".to_owned()),
+            None,
+            Some("false".to_owned()),
+        ]
+    );
+    assert_eq!(
+        strings(&s, "forall(ys, y -> y > 30)", "FROM t"),
+        [
+            Some("true".to_owned()),
+            Some("false".to_owned()),
+            Some("false".to_owned()),
+            None,
+            Some("true".to_owned()),
+        ]
+    );
+    // A NULL array folds to NULL, whatever the body.
+    assert_eq!(
+        strings(&s, "exists(CAST(NULL AS ARRAY<INT>), y -> y > 30)", ""),
+        [None]
+    );
+    assert_eq!(
+        strings(&s, "forall(CAST(NULL AS ARRAY<INT>), y -> y > 30)", ""),
+        [None]
+    );
+    // NULL marks decide nothing: no true for `exists`, no false for
+    // `forall`, so each folds to NULL.
+    assert_eq!(
+        strings(&s, "exists(array(1, NULL), x -> x > 1)", ""),
+        [None]
+    );
+    assert_eq!(
+        strings(&s, "forall(array(1, NULL), x -> x >= 1)", ""),
+        [None]
+    );
+}
+
+#[test]
+fn higher_order_functions_report_bad_arguments() {
+    let s = session();
+    // Every higher-order call takes the array and the lambda.
+    for name in ["transform", "filter", "exists", "forall"] {
+        let e = error(&s, &format!("SELECT {name}(ys) FROM t"));
+        assert_eq!(e.error_class(), ErrorClass::WrongNumArgsWithoutSuggestion);
+        assert!(e.to_string().contains(&format!("`{name}`")), "{e}");
+    }
+    // The array argument needs `ARRAY`, quoting the call as Spark does.
+    for name in ["transform", "filter", "exists", "forall"] {
+        let e = error(&s, &format!("SELECT {name}(1, x -> TRUE)"));
+        assert_eq!(
+            e.error_class(),
+            ErrorClass::DatatypeMismatchUnexpectedInputType,
+            "{name}"
+        );
+        assert_eq!(
+            e.to_string(),
+            format!(
+                "[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve \
+                 \"{name}(1, lambdafunction(true, x))\" due to data type mismatch: \
+                 The first parameter requires the \"ARRAY\" type, \
+                 however \"1\" has the type \"INT\". SQLSTATE: 42K09"
+            )
+        );
+    }
+}
+
+#[test]
+fn transform_keeps_null_elements() {
+    let s = session();
+    assert_eq!(
+        strings(&s, "transform(array(1, NULL, 3), x -> x)", ""),
+        [Some("[1, null, 3]".to_owned())]
+    );
+    assert_eq!(
+        strings(&s, "transform(array(1, NULL, 3), (x, i) -> i)", ""),
+        [Some("[0, 1, 2]".to_owned())]
+    );
+}
+
+#[test]
+fn lambdas_outside_argument_position_are_rejected() {
+    let s = session();
+    // A lambda under a cast is no higher-order call's argument (its body
+    // binds on its own, so the lambda itself is what fails).
+    let e = error(&s, "SELECT CAST((x -> 1) AS STRING)");
+    assert_eq!(e.error_class(), ErrorClass::KrishivUnsupportedFeature);
+    assert!(
+        e.to_string()
+            .contains("lambda functions outside a higher-order function"),
+        "{e}"
+    );
+}
+
+#[test]
+fn array_builds_lists() {
+    let s = session();
+    assert_eq!(
+        strings(&s, "array(1, 2, 3)", ""),
+        [Some("[1, 2, 3]".to_owned())]
+    );
+    assert_eq!(strings(&s, "array()", ""), [Some("[]".to_owned())]);
+    assert_eq!(
+        strings(&s, "array(NULL, NULL)", ""),
+        [Some("[null, null]".to_owned())]
+    );
+    // Over columns, with the common type.
+    assert_eq!(
+        strings(&s, "array(n, n * 2)", "FROM t"),
+        [
+            Some("[1, 2]".to_owned()),
+            Some("[2, 4]".to_owned()),
+            Some("[3, 6]".to_owned()),
+            Some("[4, 8]".to_owned()),
+            Some("[5, 10]".to_owned()),
+        ]
+    );
+}
+
+#[test]
+fn lambdas_outside_higher_order_functions_are_rejected() {
+    let s = session();
+    let e = error(&s, "SELECT upper(x -> x) AS v");
+    assert_eq!(
+        e.error_class(),
+        ErrorClass::InvalidLambdaFunctionCallNonHigherOrderFunction
+    );
+    assert_eq!(e.sql_state(), Some("42K0D"));
+    assert!(e.to_string().contains(
+        "org.apache.spark.sql.catalyst.expressions.Upper, which is not a higher order function"
+    ));
+    let e = error(&s, "SELECT ceil(x -> x) AS v");
+    assert_eq!(
+        e.error_class(),
+        ErrorClass::InvalidLambdaFunctionCallNonHigherOrderFunction
+    );
+    assert!(
+        e.to_string()
+            .contains("org.apache.spark.sql.catalyst.expressions.CeilExpressionBuilder$")
+    );
+    // A bare lambda binds its body without variables first (which fails),
+    // so it stays unresolved rather than reaching the lambda check.
+    let e = error(&s, "SELECT x -> x AS v");
+    assert_eq!(
+        e.error_class(),
+        ErrorClass::UnresolvedColumnWithoutSuggestion
+    );
+}
+
+#[test]
+fn constant_lambdas_of_the_wrong_type_are_rejected() {
+    let s = session();
+    for name in ["filter", "exists", "forall"] {
+        let e = error(&s, &format!("SELECT {name}(array(1, 2, 3), 1) AS v"));
+        assert_eq!(
+            e.error_class(),
+            ErrorClass::DatatypeMismatchUnexpectedInputType,
+            "{name}"
+        );
+        assert_eq!(e.sql_state(), Some("42K09"));
+        assert_eq!(
+            e.to_string(),
+            format!(
+                "[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve \
+                 \"{name}(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\" \
+                 due to data type mismatch: The second parameter requires the \"BOOLEAN\" type, \
+                 however lambdafunction(1, namedlambdavariable()) has the type \"INT\". SQLSTATE: 42K09"
+            )
+        );
+    }
+    // The array argument is checked first: it needs `ARRAY`.
+    let e = error(&s, "SELECT transform(1, x -> x) AS v");
+    assert_eq!(
+        e.error_class(),
+        ErrorClass::DatatypeMismatchUnexpectedInputType
+    );
+    assert_eq!(
+        e.to_string(),
+        "[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve \
+         \"transform(1, lambdafunction(x, x))\" due to data type mismatch: \
+         The first parameter requires the \"ARRAY\" type, however \"1\" has the type \"INT\". SQLSTATE: 42K09"
+    );
+}
+
+#[test]
+fn lambda_shapes_are_checked() {
+    let s = session();
+    // `transform` takes one or two variables, the others exactly one.
+    let e = error(&s, "SELECT transform(ys, (a, b, c) -> a) FROM t");
+    assert_eq!(
+        e.error_class(),
+        ErrorClass::InvalidLambdaFunctionCallNumArgsMismatch
+    );
+    let e = error(&s, "SELECT filter(ys, (a, b) -> a) FROM t");
+    assert_eq!(
+        e.error_class(),
+        ErrorClass::InvalidLambdaFunctionCallNumArgsMismatch
+    );
+    // Duplicate variables.
+    let e = error(&s, "SELECT transform(ys, (a, a) -> a) FROM t");
+    assert_eq!(
+        e.error_class(),
+        ErrorClass::InvalidLambdaFunctionCallDuplicateArgNames
+    );
+    // Arity of the call itself.
+    let e = error(&s, "SELECT transform(ys) FROM t");
+    assert_eq!(e.error_class(), ErrorClass::WrongNumArgsWithoutSuggestion);
+    // Aggregates and windows stay outside lambda bodies.
+    let e = error(&s, "SELECT transform(ys, y -> sum(y)) FROM t");
+    assert_eq!(e.error_class(), ErrorClass::KrishivUnsupportedFeature);
+    let e = error(
+        &s,
+        "SELECT transform(ys, y -> rank() OVER (ORDER BY n)) FROM t",
+    );
+    assert_eq!(e.error_class(), ErrorClass::KrishivUnsupportedFeature);
+}
+
+#[test]
+fn higher_order_output_names_and_types() {
+    let s = session();
+    let df = block_on(s.sql("SELECT transform(ys, y -> y + 1) FROM t")).unwrap();
+    let schema = block_on(df.schema()).unwrap();
+    let field = &schema.fields()[0];
+    assert_eq!(
+        DataType::from_arrow_field(field).unwrap(),
+        DataType::Array(ArrayType::new(DataType::Integer, false).into())
+    );
+    // Spark's `toPrettySQL` names.
+    let batches = block_on(df.collect()).unwrap();
+    assert_eq!(
+        batches[0].schema().field(0).name(),
+        "transform(ys, lambdafunction((y + 1), y))"
+    );
+}
+
+#[test]
+fn lambda_variables_respect_case_sensitivity() {
+    let s = session();
+    // Case-insensitive (the default): `n` names the `N` parameter.
+    assert_eq!(
+        strings(&s, "transform(ys, N -> n + 1)", "FROM t"),
+        [
+            Some("[33, 98]".to_owned()),
+            Some("[78, -75]".to_owned()),
+            Some("[13]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+    s.conf().set("spark.sql.caseSensitive", "true").unwrap();
+    // Case-sensitive: `n` is the outer column, `N` the (unused) element.
+    assert_eq!(
+        strings(&s, "transform(ys, N -> n + 1)", "FROM t"),
+        [
+            Some("[2, 2]".to_owned()),
+            Some("[3, 3]".to_owned()),
+            Some("[4]".to_owned()),
+            None,
+            Some("[]".to_owned()),
+        ]
+    );
+    s.conf().unset("spark.sql.caseSensitive").unwrap();
+}
+
+#[test]
+fn scalar_subqueries_in_lambda_bodies_are_rejected() {
+    let s = session();
+    let sql = "SELECT transform(ys, y -> (SELECT max(n) FROM t)) FROM t";
+    let err = match block_on(s.sql(sql)) {
+        Err(e) => e,
+        Ok(df) => match block_on(df.collect()) {
+            Err(e) => e,
+            Ok(_) => panic!("{sql} ran"),
+        },
+    };
+    assert_eq!(
+        err.error_class(),
+        ErrorClass::KrishivUnsupportedFeature,
+        "{err}"
+    );
+    assert!(
+        err.to_string()
+            .contains("scalar subqueries in lambda functions"),
+        "{err}"
+    );
+}
+
+#[test]
+fn large_lists_are_rejected() {
+    use arrow_array::LargeListArray;
+    let s = Session::new().unwrap();
+    let large = LargeListArray::from_iter_primitive::<arrow_array::types::Int32Type, _, _>(vec![
+        Some(vec![Some(1), Some(2)]),
+        Some(vec![Some(3)]),
+    ]);
+    let schema = Arc::new(Schema::new(vec![Field::new(
+        "ys",
+        large.data_type().clone(),
+        true,
+    )]));
+    let batch =
+        RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(large) as ArrayRef]).unwrap();
+    s.register_batches("u", schema, vec![batch]).unwrap();
+    let sql = "SELECT transform(ys, y -> y + 1) FROM u";
+    let err = match block_on(s.sql(sql)) {
+        Err(e) => e,
+        Ok(df) => match block_on(df.collect()) {
+            Err(e) => e,
+            Ok(_) => panic!("{sql} ran over a LargeList"),
+        },
+    };
+    // A graceful engine error, never a panic or wrong rows.
+    assert!(
+        err.to_string().contains("no list") || err.to_string().contains("non-list"),
+        "{err}"
+    );
+}
diff --git a/crates/krishiv-sql/src/lower.rs b/crates/krishiv-sql/src/lower.rs
index 692d6dff8..bcd396490 100644
--- a/crates/krishiv-sql/src/lower.rs
+++ b/crates/krishiv-sql/src/lower.rs
@@ -1588,7 +1588,16 @@ impl Lowerer {
             ExprKind::Collate(..) => return Err(unsupported("COLLATE", sp)),
             ExprKind::VariantGet(..) => return Err(unsupported("variant paths", sp)),
             ExprKind::TableArgument(_) => return Err(unsupported("TABLE arguments", sp)),
-            ExprKind::Lambda { .. } => return Err(unsupported("lambda functions", sp)),
+            ExprKind::Lambda { params, body } => {
+                let params = params.iter().map(|p| p.value.clone()).collect();
+                let body = self.arg(body)?;
+                self.ex(
+                    IrExpr::lambda(params, Arc::unwrap_or_clone(body))
+                        .node
+                        .clone(),
+                    sp,
+                )
+            }
             ExprKind::Row(_) => {
                 return Err(unsupported("row and struct constructors", sp));
             }
diff --git a/crates/krishiv-sql/tests/snapshots/lower__constructs_lower_or_are_named_as_unsupported.snap b/crates/krishiv-sql/tests/snapshots/lower__constructs_lower_or_are_named_as_unsupported.snap
index 7875e8163..d066727f8 100644
--- a/crates/krishiv-sql/tests/snapshots/lower__constructs_lower_or_are_named_as_unsupported.snap
+++ b/crates/krishiv-sql/tests/snapshots/lower__constructs_lower_or_are_named_as_unsupported.snap
@@ -1,5 +1,6 @@
 ---
 source: crates/krishiv-sql/tests/lower.rs
+assertion_line: 51
 expression: "report(&[\"SELECT 1\", \"SELECT DISTINCT a FROM t\",\n\"SELECT /*+ BROADCAST(t) */ a FROM t\",\n\"SELECT a FROM t UNION SELECT a FROM u\", \"VALUES (1)\",\n\"SELECT * FROM VALUES (1) AS v(a)\", \"SELECT * FROM range(3)\",\n\"SELECT a FROM t LATERAL VIEW explode(b) x AS y\",\n\"SELECT row_number() OVER (ORDER BY a) FROM t\",\n\"SELECT a FROM t GROUP BY ROLLUP (a)\", \"SELECT a FROM t GROUP BY a WITH CUBE\",\n\"SELECT * FROM t NATURAL JOIN u\", \"SELECT * FROM t, LATERAL (SELECT a)\",\n\"SELECT * FROM t VERSION AS OF 1\", \"SELECT a FROM t CLUSTER BY a\",\n\"SELECT a FROM t DISTRIBUTE BY a\", \"SELECT a FROM t LIMIT 1 OFFSET 2\",\n\"FROM t SELECT a LIMIT 1 OFFSET 2\", \"FROM t SELECT a CLUSTER BY a\",\n\"FROM t SELECT a DISTRIBUTE BY a\", \"FROM t SELECT a WINDOW w AS (ORDER BY a)\",\n\"SELECT a FROM t WINDOW w AS (ORDER BY a)\", \"SELECT a FROM t QUALIFY a > 1\",\n\"WITH RECURSIVE r AS (SELECT a FROM t) SELECT * FROM r\",\n\"SELECT * EXCEPT (a) FROM t\", \"SELECT a FROM t INTERSECT SELECT a FROM u\",\n\"SELECT a FROM t EXCEPT ALL SELECT a FROM u\",\n\"SELECT /*+ BROADCAST(t), MERGE(u) */ /*+ COALESCE(2) */ DISTINCT a FROM t, u\",\n\"SELECT a FROM t UNION ALL SELECT b FROM u UNION SELECT c FROM v\",\n\"SELECT x[0] FROM t\", \"SELECT (a).b.c FROM t\", \"SELECT f(a).b FROM t\",\n\"SELECT transform(a, x -> x) FROM t\", \"SELECT (a, b) FROM t\",\n\"SELECT a LIKE ANY ('x', 'y') FROM t\", \"SELECT ? FROM t\",\n\"SELECT INTERVAL 1 DAY FROM t\",\n\"SELECT TIMESTAMP '2020-01-01 00:00:00' FROM t\", \"SELECT db.f(a) FROM t\",\n\"SELECT f(x => 1) FROM t\",\n\"SELECT percentile_cont(0.5) WITHIN GROUP (ORDER BY a) FROM t\",\n\"SELECT sum(a) IGNORE NULLS FROM t\", \"SELECT * FROM t WITH (k = x)\",\n\"FROM t SELECT a SELECT b\",\n\"SELECT * FROM parquet.`s3a://k:Canary-7f3a9c@b/p` WITH ('password' = 'Canary-7f3a9c')\",\n\"WITH c (x) AS (SELECT a FROM t) SELECT x FROM c ORDER BY x LIMIT ALL\",\n\"FROM t SELECT a SORT BY a\",\n\"SELECT a FROM t WHERE (a, b) IN (SELECT a, d FROM u) AND a NOT BETWEEN 1 AND 2\",\n\"SELECT a <=> 1, a IS DISTINCT FROM 1, a IS NOT DISTINCT FROM 1, a IS TRUE, a IS NOT FALSE, a IS UNKNOWN, a IS NOT UNKNOWN FROM t\",\n\"SELECT +a, ~a, a DIV 2, a & 1, a | 1, a ^ 1, a << 1, a >> 1, a >>> 1, a || b FROM t\",\n\"SELECT CASE a WHEN 1 THEN 'x' END, b ILIKE 'x' ESCAPE '/', b NOT RLIKE 'x', TRY_CAST(a AS INT) FROM t\",\n\"SELECT * FROM (t JOIN u ON true) x CROSS JOIN v LEFT SEMI JOIN w ON true\",\n\"TABLE t\", \"(SELECT a FROM t) ORDER BY a\", \"FROM t SELECT a UNION SELECT b\",\n\"WITH RECURSIVE c MAX RECURSION LEVEL 3 AS (SELECT a FROM t) SELECT a FROM c\",\n\"SELECT explode(a) AS (x, y) FROM t\",\n\"SELECT * FROM t JOIN LATERAL (SELECT a) s\",\n\"SELECT * FROM t WITH (k = true, n = 2) RIGHT JOIN (SELECT a FROM u) USING (a)\",\n\"SELECT -a, a % 2, a IS NULL, NULL FROM t ORDER BY a DESC NULLS FIRST, b NULLS LAST\",\n\"SELECT (t.a).b, ((a)).c.d FROM t\", \"SELECT 1BD, 1e3BD FROM t\",])"
 ---
 SELECT 1
@@ -67,7 +68,7 @@ SELECT (a).b.c FROM t
 SELECT f(a).b FROM t
   => Project [f(a).b] | +- Read t | 
 SELECT transform(a, x -> x) FROM t
-  => [KRISHIV_UNSUPPORTED_FEATURE] The feature lambda functions is not supported by Krishiv yet. SQLSTATE: 0A000 @ 20..26
+  => Project [transform(a, (x) -> x)] | +- Read t | 
 SELECT (a, b) FROM t
   => [KRISHIV_UNSUPPORTED_FEATURE] The feature row and struct constructors is not supported by Krishiv yet. SQLSTATE: 0A000 @ 7..13
 SELECT a LIKE ANY ('x', 'y') FROM t
diff --git a/crates/krishiv-testkit/src/golden/session_engine.rs b/crates/krishiv-testkit/src/golden/session_engine.rs
index a3193d242..da59d9c54 100644
--- a/crates/krishiv-testkit/src/golden/session_engine.rs
+++ b/crates/krishiv-testkit/src/golden/session_engine.rs
@@ -364,17 +364,182 @@ fn arrow_cell(col: &ArrayRef, row: usize, ty: &DataType) -> Result<Cell, EngineE
         (DataType::TimestampNtz, ArrowType::Timestamp(..)) => {
             Cell::TimestampNtz(col.as_primitive::<TimestampMicrosecondType>().value(row))
         }
-        (DataType::Struct(st), ArrowType::Struct(_)) => {
-            let s = col.as_struct();
-            st.fields()
-                .iter()
-                .zip(s.columns())
-                .map(|(f, child)| {
-                    arrow_cell(child, row, f.data_type()).map(|c| (f.name().to_owned(), c))
-                })
-                .collect::<Result<Vec<_>, _>>()
-                .map(Cell::Struct)?
+        (DataType::Array(element), ArrowType::List(_) | ArrowType::LargeList(_)) => {
+            Cell::Array(list_cells(col, row, element)?)
         }
+        (DataType::Map(map), ArrowType::Map(..)) => map_cell(col, row, map)?,
+        (DataType::Struct(struct_), ArrowType::Struct(_)) => struct_cell(col, row, struct_)?,
+        _ => return Err(unexpected()),
+    })
+}
+
+/// The elements of the list at `row` of `col` (a `List` or `LargeList`) as
+/// cells of the element type.
+fn list_cells(
+    col: &ArrayRef,
+    row: usize,
+    element: &krishiv_types::ArrayType,
+) -> Result<Vec<Cell>, EngineError> {
+    use arrow_buffer::ArrowNativeType as _;
+    // Offsets are non-negative by construction (`OffsetBuffer`) and no
+    // larger than the values' length (checked there), so they fit.
+    let (start, stop, values) = match col.data_type() {
+        ArrowType::List(_) => {
+            let list = col.as_list::<i32>();
+            (
+                list.value_offsets()[row].as_usize(),
+                list.value_offsets()[row + 1].as_usize(),
+                Arc::clone(list.values()),
+            )
+        }
+        ArrowType::LargeList(_) => {
+            let list = col.as_list::<i64>();
+            (
+                list.value_offsets()[row].as_usize(),
+                list.value_offsets()[row + 1].as_usize(),
+                Arc::clone(list.values()),
+            )
+        }
+        other => {
+            return Err(harness_error(format!(
+                "Arrow type {other} for {}",
+                DataType::Array(Arc::new(element.clone())).catalog_string()
+            )));
+        }
+    };
+    (start..stop)
+        .map(|i| nested_cell(&values, i, element.element_type()))
+        .collect()
+}
+
+/// The map at `row` of `col` as key/value cells in storage order (the
+/// renderer sorts them as Spark does).
+fn map_cell(col: &ArrayRef, row: usize, map: &krishiv_types::MapType) -> Result<Cell, EngineError> {
+    use arrow_buffer::ArrowNativeType as _;
+    let ArrowType::Map(..) = col.data_type() else {
+        return Err(harness_error(format!(
+            "Arrow type {} for {}",
+            col.data_type(),
+            DataType::Map(Arc::new(map.clone())).catalog_string()
+        )));
+    };
+    // A map's entries are a struct of its keys and values by construction
+    // (`MapArray`), so no shape check repeats here.
+    let entries = col.as_map();
+    // Offsets are non-negative by construction (`OffsetBuffer`) and no
+    // larger than the entries' length (checked there), so they fit.
+    let (start, stop) = (
+        entries.value_offsets()[row].as_usize(),
+        entries.value_offsets()[row + 1].as_usize(),
+    );
+    let keys = entries.keys();
+    let values = entries.values();
+    (start..stop)
+        .map(|i| {
+            Ok((
+                nested_cell(keys, i, map.key_type())?,
+                nested_cell(values, i, map.value_type())?,
+            ))
+        })
+        .collect::<Result<Vec<_>, _>>()
+        .map(Cell::Map)
+}
+
+/// The struct at `row` of `col` as its fields' cells.
+fn struct_cell(
+    col: &ArrayRef,
+    row: usize,
+    struct_: &krishiv_types::StructType,
+) -> Result<Cell, EngineError> {
+    let ArrowType::Struct(fields) = col.data_type() else {
+        return Err(harness_error(format!(
+            "Arrow type {} for {}",
+            col.data_type(),
+            DataType::Struct(struct_.clone()).catalog_string()
+        )));
+    };
+    let values = col.as_struct();
+    if fields.len() != struct_.fields().len() {
+        return Err(harness_error(format!(
+            "Arrow struct {} for {}",
+            col.data_type(),
+            DataType::Struct(struct_.clone()).catalog_string()
+        )));
+    }
+    struct_
+        .fields()
+        .iter()
+        .zip(fields.iter())
+        .enumerate()
+        .map(|(i, (f, _))| {
+            Ok((
+                f.name().to_owned(),
+                nested_cell(values.column(i), row, f.data_type())?,
+            ))
+        })
+        .collect::<Result<Vec<_>, _>>()
+        .map(Cell::Struct)
+}
+
+/// The value at `row` of `col`, a (possibly nested) value of Spark type
+/// `ty`, as a cell. NULLs are `Null` at every level.
+fn nested_cell(col: &ArrayRef, row: usize, ty: &DataType) -> Result<Cell, EngineError> {
+    if col.is_null(row) {
+        return Ok(Cell::Null);
+    }
+    let unexpected = || {
+        harness_error(format!(
+            "Arrow type {} for {}",
+            col.data_type(),
+            ty.catalog_string()
+        ))
+    };
+    Ok(match (ty, col.data_type()) {
+        (DataType::Null, _) => Cell::Null,
+        (DataType::Boolean, ArrowType::Boolean) => Cell::Bool(col.as_boolean().value(row)),
+        (DataType::Byte, ArrowType::Int8) => {
+            Cell::Int(i64::from(col.as_primitive::<Int8Type>().value(row)))
+        }
+        (DataType::Short, ArrowType::Int16) => {
+            Cell::Int(i64::from(col.as_primitive::<Int16Type>().value(row)))
+        }
+        (DataType::Integer, ArrowType::Int32) => {
+            Cell::Int(i64::from(col.as_primitive::<Int32Type>().value(row)))
+        }
+        (DataType::Long, ArrowType::Int64) => Cell::Int(col.as_primitive::<Int64Type>().value(row)),
+        (DataType::Float, ArrowType::Float32) => {
+            Cell::Float(col.as_primitive::<Float32Type>().value(row))
+        }
+        (DataType::Double, ArrowType::Float64) => {
+            Cell::Double(col.as_primitive::<Float64Type>().value(row))
+        }
+        (DataType::Decimal(d), ArrowType::Decimal128(..)) => Cell::Decimal(
+            col.as_primitive::<Decimal128Type>().value(row),
+            u32::from(d.scale()),
+        ),
+        (DataType::String, ArrowType::Utf8View) => {
+            Cell::Str(col.as_string_view().value(row).to_owned())
+        }
+        (DataType::String, ArrowType::Utf8) => {
+            Cell::Str(col.as_string::<i32>().value(row).to_owned())
+        }
+        (DataType::String, ArrowType::LargeUtf8) => {
+            Cell::Str(col.as_string::<i64>().value(row).to_owned())
+        }
+        (DataType::Date, ArrowType::Date32) => {
+            Cell::Date(col.as_primitive::<Date32Type>().value(row))
+        }
+        (DataType::Timestamp, ArrowType::Timestamp(..)) => {
+            Cell::Timestamp(col.as_primitive::<TimestampMicrosecondType>().value(row))
+        }
+        (DataType::TimestampNtz, ArrowType::Timestamp(..)) => {
+            Cell::TimestampNtz(col.as_primitive::<TimestampMicrosecondType>().value(row))
+        }
+        (DataType::Array(element), ArrowType::List(_) | ArrowType::LargeList(_)) => {
+            Cell::Array(list_cells(col, row, element)?)
+        }
+        (DataType::Map(map), ArrowType::Map(..)) => map_cell(col, row, map)?,
+        (DataType::Struct(struct_), ArrowType::Struct(_)) => struct_cell(col, row, struct_)?,
         _ => return Err(unexpected()),
     })
 }
@@ -892,4 +1057,338 @@ mod tests {
         assert!(fixture_batch(&nested).map_err(err)?.is_none());
         Ok(())
     }
+
+    fn list_col(offsets: Vec<i32>, values: Vec<Option<i32>>) -> ArrayRef {
+        use arrow_array::{Int32Array, ListArray};
+        use arrow_buffer::{OffsetBuffer, ScalarBuffer};
+        use arrow_schema::Field;
+        Arc::new(ListArray::new(
+            Arc::new(Field::new(
+                "element",
+                ArrowType::Int32,
+                values.iter().any(Option::is_none),
+            )),
+            OffsetBuffer::new(ScalarBuffer::from(offsets)),
+            Arc::new(Int32Array::from(values)),
+            None,
+        ))
+    }
+
+    fn int_array_element() -> krishiv_types::ArrayType {
+        krishiv_types::ArrayType::new(krishiv_types::DataType::Integer, true)
+    }
+
+    #[test]
+    fn nested_lists_render_their_elements() -> R {
+        use arrow_array::Int32Array;
+        // `[[1, NULL], [], [3]]`.
+        let col = list_col(vec![0, 2, 2, 3], vec![Some(1), None, Some(3)]);
+        let element = int_array_element();
+        assert_eq!(
+            list_cells(&col, 0, &element).map_err(err)?,
+            vec![Cell::Int(1), Cell::Null]
+        );
+        assert_eq!(list_cells(&col, 1, &element).map_err(err)?, vec![]);
+        assert_eq!(
+            list_cells(&col, 2, &element).map_err(err)?,
+            vec![Cell::Int(3)]
+        );
+        // A column that holds no list at all is a harness error.
+        let ints: ArrayRef = Arc::new(Int32Array::from(vec![1]));
+        let got = list_cells(&ints, 0, &element).unwrap_err();
+        assert!(got.message.contains("Arrow type Int32"), "{}", got.message);
+        Ok(())
+    }
+
+    #[test]
+    fn large_lists_render_like_lists() -> R {
+        use arrow_array::{Int32Array, LargeListArray};
+        use arrow_buffer::{OffsetBuffer, ScalarBuffer};
+        use arrow_schema::Field;
+        let values: ArrayRef = Arc::new(Int32Array::from(vec![Some(4), Some(5)]));
+        let col: ArrayRef = Arc::new(LargeListArray::new(
+            Arc::new(Field::new("element", ArrowType::Int32, false)),
+            OffsetBuffer::new(ScalarBuffer::from(vec![0_i64, 2])),
+            values,
+            None,
+        ));
+        assert_eq!(
+            list_cells(&col, 0, &int_array_element()).map_err(err)?,
+            vec![Cell::Int(4), Cell::Int(5)]
+        );
+        // A nested list of lists recurses.
+        let inner = list_col(vec![0, 2, 3], vec![Some(1), None, Some(3)]);
+        let nested: ArrayRef = Arc::new(arrow_array::ListArray::new(
+            Arc::new(Field::new(
+                "element",
+                ArrowType::List(Arc::new(Field::new("element", ArrowType::Int32, true))),
+                true,
+            )),
+            OffsetBuffer::new(ScalarBuffer::from(vec![0, 2])),
+            inner,
+            None,
+        ));
+        let lists =
+            krishiv_types::ArrayType::new(DataType::Array(Arc::new(int_array_element())), true);
+        assert_eq!(
+            list_cells(&nested, 0, &lists).map_err(err)?,
+            vec![
+                Cell::Array(vec![Cell::Int(1), Cell::Null]),
+                Cell::Array(vec![Cell::Int(3)]),
+            ]
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn nested_scalars_render_by_spark_type() -> R {
+        use arrow_array::{
+            BinaryArray, BooleanArray, Date32Array, Decimal128Array, Float32Array, Float64Array,
+            Int8Array, Int16Array, Int32Array, Int64Array, LargeStringArray, StringArray,
+            StringViewArray, TimestampMicrosecondArray,
+        };
+        let cell = |col: ArrayRef, ty: DataType| nested_cell(&col, 0, &ty).map_err(err);
+        let int = |v: Vec<Option<i32>>| -> ArrayRef { Arc::new(Int32Array::from(v)) };
+        // A NULL row is NULL whatever the type; an untyped NULL type is NULL
+        // even over a non-null row.
+        assert_eq!(cell(int(vec![None]), DataType::Integer)?, Cell::Null);
+        assert_eq!(cell(int(vec![Some(7)]), DataType::Null)?, Cell::Null);
+        assert_eq!(
+            cell(Arc::new(BooleanArray::from(vec![true])), DataType::Boolean)?,
+            Cell::Bool(true)
+        );
+        assert_eq!(
+            cell(Arc::new(Int8Array::from(vec![-3])), DataType::Byte)?,
+            Cell::Int(-3)
+        );
+        assert_eq!(
+            cell(Arc::new(Int16Array::from(vec![-300])), DataType::Short)?,
+            Cell::Int(-300)
+        );
+        assert_eq!(cell(int(vec![Some(7)]), DataType::Integer)?, Cell::Int(7));
+        assert_eq!(
+            cell(Arc::new(Int64Array::from(vec![8])), DataType::Long)?,
+            Cell::Int(8)
+        );
+        assert_eq!(
+            cell(Arc::new(Float32Array::from(vec![1.5])), DataType::Float)?,
+            Cell::Float(1.5)
+        );
+        assert_eq!(
+            cell(Arc::new(Float64Array::from(vec![2.5])), DataType::Double)?,
+            Cell::Double(2.5)
+        );
+        let dec: ArrayRef = Arc::new(
+            Decimal128Array::from(vec![150])
+                .with_precision_and_scale(5, 2)
+                .map_err(|e| format!("decimal: {e}"))?,
+        );
+        assert_eq!(
+            cell(
+                dec,
+                DataType::Decimal(
+                    krishiv_types::DecimalType::try_new(5, 2).map_err(|e| format!("{e:?}"))?
+                )
+            )?,
+            Cell::Decimal(150, 2)
+        );
+        assert_eq!(
+            cell(Arc::new(StringArray::from(vec!["a"])), DataType::String)?,
+            Cell::Str("a".into())
+        );
+        assert_eq!(
+            cell(
+                Arc::new(LargeStringArray::from(vec!["b"])),
+                DataType::String
+            )?,
+            Cell::Str("b".into())
+        );
+        assert_eq!(
+            cell(Arc::new(StringViewArray::from(vec!["c"])), DataType::String)?,
+            Cell::Str("c".into())
+        );
+        assert_eq!(
+            cell(Arc::new(Date32Array::from(vec![1])), DataType::Date)?,
+            Cell::Date(1)
+        );
+        assert_eq!(
+            cell(
+                Arc::new(TimestampMicrosecondArray::from(vec![1_000_000])),
+                DataType::Timestamp
+            )?,
+            Cell::Timestamp(1_000_000)
+        );
+        assert_eq!(
+            cell(
+                Arc::new(TimestampMicrosecondArray::from(vec![2_000_000])),
+                DataType::TimestampNtz
+            )?,
+            Cell::TimestampNtz(2_000_000)
+        );
+        // A nested `binary` has no cell: the harness reports the mismatch.
+        let binary: ArrayRef = Arc::new(BinaryArray::from(vec![&b"a"[..]]));
+        let got = nested_cell(&binary, 0, &DataType::Binary).unwrap_err();
+        assert!(got.message.contains("Arrow type Binary"), "{}", got.message);
+        // So does any other Arrow/value mismatch.
+        let got = nested_cell(&int(vec![Some(1)]), 0, &DataType::String).unwrap_err();
+        assert!(
+            got.message.contains("Arrow type Int32 for string"),
+            "{}",
+            got.message
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn nested_maps_render_key_value_cells() -> R {
+        use arrow_array::{Int32Array, MapArray, StringArray, StructArray};
+        use arrow_buffer::{OffsetBuffer, ScalarBuffer};
+        use arrow_schema::Field;
+        let keys: ArrayRef = Arc::new(StringArray::from(vec!["k1", "k2"]));
+        let values: ArrayRef = Arc::new(Int32Array::from(vec![Some(1), None]));
+        let entries = StructArray::new(
+            vec![
+                Field::new("key", ArrowType::Utf8, false),
+                Field::new("value", ArrowType::Int32, true),
+            ]
+            .into(),
+            vec![keys, values],
+            None,
+        );
+        let map_ty = krishiv_types::MapType::new(DataType::String, DataType::Integer, true);
+        let field = Field::new("entries", entries.data_type().clone(), false);
+        let col: ArrayRef = Arc::new(MapArray::new(
+            Arc::new(field),
+            OffsetBuffer::new(ScalarBuffer::from(vec![0, 2])),
+            entries,
+            None,
+            false,
+        ));
+        assert_eq!(
+            map_cell(&col, 0, &map_ty).map_err(err)?,
+            Cell::Map(vec![
+                (Cell::Str("k1".into()), Cell::Int(1)),
+                (Cell::Str("k2".into()), Cell::Null),
+            ])
+        );
+        assert_eq!(
+            arrow_cell(&col, 0, &DataType::Map(Arc::new(map_ty.clone()))).map_err(err)?,
+            Cell::Map(vec![
+                (Cell::Str("k1".into()), Cell::Int(1)),
+                (Cell::Str("k2".into()), Cell::Null),
+            ])
+        );
+        assert_eq!(
+            nested_cell(&col, 0, &DataType::Map(Arc::new(map_ty))).map_err(err)?,
+            Cell::Map(vec![
+                (Cell::Str("k1".into()), Cell::Int(1)),
+                (Cell::Str("k2".into()), Cell::Null),
+            ])
+        );
+        // A column that holds no map at all is a harness error.
+        let ints: ArrayRef = Arc::new(Int32Array::from(vec![1]));
+        let bad = krishiv_types::MapType::new(DataType::String, DataType::Integer, false);
+        let got = map_cell(&ints, 0, &bad).unwrap_err();
+        assert!(got.message.contains("Arrow type Int32"), "{}", got.message);
+        Ok(())
+    }
+
+    #[test]
+    fn nested_structs_render_named_fields() -> R {
+        use arrow_array::{Int32Array, StringArray, StructArray};
+        use arrow_schema::Field;
+        let struct_ty = krishiv_types::StructType::new([
+            krishiv_types::StructField::new("a", DataType::Integer, true),
+            krishiv_types::StructField::new("s", DataType::String, true),
+        ]);
+        let fields: arrow_schema::Fields = vec![
+            Field::new("a", ArrowType::Int32, true),
+            Field::new("s", ArrowType::Utf8, true),
+        ]
+        .into();
+        let col: ArrayRef = Arc::new(StructArray::new(
+            fields,
+            vec![
+                Arc::new(Int32Array::from(vec![Some(1), None])) as ArrayRef,
+                Arc::new(StringArray::from(vec![Some("x"), None])) as ArrayRef,
+            ],
+            None,
+        ));
+        assert_eq!(
+            struct_cell(&col, 0, &struct_ty).map_err(err)?,
+            Cell::Struct(vec![
+                ("a".to_owned(), Cell::Int(1)),
+                ("s".to_owned(), Cell::Str("x".into())),
+            ])
+        );
+        assert_eq!(
+            struct_cell(&col, 1, &struct_ty).map_err(err)?,
+            Cell::Struct(vec![
+                ("a".to_owned(), Cell::Null),
+                ("s".to_owned(), Cell::Null),
+            ])
+        );
+        assert_eq!(
+            arrow_cell(&col, 0, &DataType::Struct(struct_ty.clone())).map_err(err)?,
+            Cell::Struct(vec![
+                ("a".to_owned(), Cell::Int(1)),
+                ("s".to_owned(), Cell::Str("x".into())),
+            ])
+        );
+        assert_eq!(
+            nested_cell(&col, 0, &DataType::Struct(struct_ty.clone())).map_err(err)?,
+            Cell::Struct(vec![
+                ("a".to_owned(), Cell::Int(1)),
+                ("s".to_owned(), Cell::Str("x".into())),
+            ])
+        );
+        // A column that holds no struct, and a struct of another shape, are
+        // harness errors.
+        let ints: ArrayRef = Arc::new(Int32Array::from(vec![1]));
+        let got = struct_cell(&ints, 0, &struct_ty).unwrap_err();
+        assert!(got.message.contains("Arrow type Int32"), "{}", got.message);
+        let narrow = krishiv_types::StructType::new([krishiv_types::StructField::new(
+            "a",
+            DataType::Integer,
+            true,
+        )]);
+        let got = struct_cell(&col, 0, &narrow).unwrap_err();
+        assert!(got.message.contains("Arrow struct"), "{}", got.message);
+        Ok(())
+    }
+
+    #[test]
+    fn arrow_cell_reports_type_mismatches() -> R {
+        use arrow_array::{BooleanArray, Int32Array, LargeBinaryArray};
+        // A value of another Arrow type is a harness error naming both sides.
+        let bools: ArrayRef = Arc::new(BooleanArray::from(vec![true]));
+        let got = arrow_cell(&bools, 0, &DataType::Integer).unwrap_err();
+        assert!(
+            got.message.contains("Arrow type Boolean for int"),
+            "{}",
+            got.message
+        );
+        // A `STRING` over a column with no bytes to read has no cell, and
+        // neither does a `BINARY` over a non-binary column.
+        let ints: ArrayRef = Arc::new(Int32Array::from(vec![1]));
+        let got = arrow_cell(&ints, 0, &DataType::String).unwrap_err();
+        assert!(
+            got.message.contains("Arrow type Int32 for string"),
+            "{}",
+            got.message
+        );
+        let got = arrow_cell(&ints, 0, &DataType::Binary).unwrap_err();
+        assert!(
+            got.message.contains("Arrow type Int32 for binary"),
+            "{}",
+            got.message
+        );
+        // Every binary carrier reads its bytes.
+        let large: ArrayRef = Arc::new(LargeBinaryArray::from(vec![&b"ab"[..]]));
+        assert_eq!(
+            arrow_cell(&large, 0, &DataType::Binary).map_err(err)?,
+            Cell::Binary(b"ab".to_vec())
+        );
+        Ok(())
+    }
 }
diff --git a/proto/krishiv/plan/v1/plan.proto b/proto/krishiv/plan/v1/plan.proto
index 406e9232e..72d61512d 100644
--- a/proto/krishiv/plan/v1/plan.proto
+++ b/proto/krishiv/plan/v1/plan.proto
@@ -584,9 +584,21 @@ message Expr {
     AliasExpr alias = 7;
     // feature: struct_field
     FieldExpr field = 8;
+    // feature: lambda_functions
+    Lambda lambda = 9;
+    // feature: lambda_functions
+    BoundColumn lambda_var = 10;
   }
 }
 
+// A lambda (`x -> body`): the bound body of a higher-order function's
+// argument, with its variables as `lambda_var` leaves.
+// feature: lambda_functions
+message Lambda {
+  repeated BoundColumn params = 1;
+  uint32 body = 2;
+}
+
 message AliasExpr {
   uint32 expr = 1;
   BoundColumn output = 2;
diff --git a/python/krishiv/sql/_generated_functions.py b/python/krishiv/sql/_generated_functions.py
index 7233ceb30..12d2e94a8 100644
--- a/python/krishiv/sql/_generated_functions.py
+++ b/python/krishiv/sql/_generated_functions.py
@@ -29,6 +29,7 @@
     "acos",
     "acosh",
     "add_months",
+    "array",
     "ascii",
     "asin",
     "asinh",
@@ -290,6 +291,11 @@ def add_months(start: ColumnOrName, months: ColumnOrName | int) -> Column:
     return _call("add_months", _named(start, "start"), _int_or_col(months, "months"))
 
 
+def array(*cols: ColumnOrName) -> Column:
+    """Calls the registry function ``array``."""
+    return _call("array", *_cols(cols))
+
+
 def ascii(col: ColumnOrName) -> Column:
     """Calls the registry function ``ascii``."""
     return _call("ascii", _named(col, "col"))
diff --git a/python/krishiv/sql/_generated_functions.pyi b/python/krishiv/sql/_generated_functions.pyi
index 9db616f2a..ac43727be 100644
--- a/python/krishiv/sql/_generated_functions.pyi
+++ b/python/krishiv/sql/_generated_functions.pyi
@@ -10,6 +10,7 @@ __all__ = [
     "acos",
     "acosh",
     "add_months",
+    "array",
     "ascii",
     "asin",
     "asinh",
@@ -254,6 +255,7 @@ def abs(col: ColumnOrName) -> Column: ...
 def acos(col: ColumnOrName) -> Column: ...
 def acosh(col: ColumnOrName) -> Column: ...
 def add_months(start: ColumnOrName, months: ColumnOrName | int) -> Column: ...
+def array(*cols: ColumnOrName) -> Column: ...
 def ascii(col: ColumnOrName) -> Column: ...
 def asin(col: ColumnOrName) -> Column: ...
 def asinh(col: ColumnOrName) -> Column: ...
diff --git a/python/tests/_pyspark_signatures.py b/python/tests/_pyspark_signatures.py
index eae19fa61..e02742a6d 100644
--- a/python/tests/_pyspark_signatures.py
+++ b/python/tests/_pyspark_signatures.py
@@ -13,6 +13,7 @@
     "acos": "col",
     "acosh": "col",
     "add_months": "start, months",
+    "array": "*cols",
     "asc": "col",
     "ascii": "col",
     "asin": "col",
diff --git a/tests/fixtures/analysis/registry-matrix/%26.json b/tests/fixtures/analysis/registry-matrix/%26.json
index 64bf16d84..6ea8afb7e 100644
--- a/tests/fixtures/analysis/registry-matrix/%26.json
+++ b/tests/fixtures/analysis/registry-matrix/%26.json
@@ -24,14 +24,6 @@
       "id": "&#5659a97d9ba4/ansi_off",
       "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) & 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "&#6123fc249fec/ansi_on",
-      "reason": "SELECT 3 & (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "&#6123fc249fec/ansi_off",
-      "reason": "SELECT 3 & (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "&#8ff00391103b/ansi_on",
       "reason": "SELECT (INTERVAL '1 02:03:04' DAY TO SECOND) & 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -48,14 +40,6 @@
       "id": "&#9061d84a5e85/ansi_off",
       "reason": "SELECT 3 & (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "&#c2f3c9f79da5/ansi_on",
-      "reason": "SELECT (array(1, 2)) & 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "&#c2f3c9f79da5/ansi_off",
-      "reason": "SELECT (array(1, 2)) & 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "&#c5402653e378/ansi_on",
       "reason": "SELECT 3 & (INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
diff --git a/tests/fixtures/analysis/registry-matrix/%3C%3C.json b/tests/fixtures/analysis/registry-matrix/%3C%3C.json
index cce0eda0f..0fcc38470 100644
--- a/tests/fixtures/analysis/registry-matrix/%3C%3C.json
+++ b/tests/fixtures/analysis/registry-matrix/%3C%3C.json
@@ -8,14 +8,6 @@
       "id": "<<#1dacd979bb38/ansi_off",
       "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) << 1 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "<<#414a74fe9693/ansi_on",
-      "reason": "SELECT 2 << (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "<<#414a74fe9693/ansi_off",
-      "reason": "SELECT 2 << (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "<<#5564cec7503a/ansi_on",
       "reason": "SELECT 2 << (INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,14 +32,6 @@
       "id": "<<#7e74e30d017a/ansi_off",
       "reason": "SELECT 2 << (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "<<#83a6d37169a0/ansi_on",
-      "reason": "SELECT (array(1, 2)) << 1 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "<<#83a6d37169a0/ansi_off",
-      "reason": "SELECT (array(1, 2)) << 1 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "<<#b68d0e5fe063/ansi_on",
       "reason": "SELECT 2 << (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json b/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json
index 206f53553..41656bcf2 100644
--- a/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json
+++ b/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json
@@ -39,14 +39,6 @@
     {
       "id": ">>>#d2b78b328d9c/ansi_off",
       "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) >>> 1 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": ">>>#daf9cb7bc89b/ansi_on",
-      "reason": "SELECT 4 >>> (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": ">>>#daf9cb7bc89b/ansi_off",
-      "reason": "SELECT 4 >>> (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/%3E%3E.json b/tests/fixtures/analysis/registry-matrix/%3E%3E.json
index ca0e69e8f..769c1f0d3 100644
--- a/tests/fixtures/analysis/registry-matrix/%3E%3E.json
+++ b/tests/fixtures/analysis/registry-matrix/%3E%3E.json
@@ -39,14 +39,6 @@
     {
       "id": ">>#be5e649df4d4/ansi_off",
       "reason": "SELECT (INTERVAL '1 02:03:04' DAY TO SECOND) >> 1 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": ">>#f7b11ad82d07/ansi_on",
-      "reason": "SELECT 4 >> (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": ">>#f7b11ad82d07/ansi_off",
-      "reason": "SELECT 4 >> (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/%5E.json b/tests/fixtures/analysis/registry-matrix/%5E.json
index c8fe03350..b9425dd44 100644
--- a/tests/fixtures/analysis/registry-matrix/%5E.json
+++ b/tests/fixtures/analysis/registry-matrix/%5E.json
@@ -16,22 +16,6 @@
       "id": "^#2e9b5ee868b2/ansi_off",
       "reason": "SELECT 3 ^ (INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "^#4afd3e5c8033/ansi_on",
-      "reason": "SELECT (array(1, 2)) ^ 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "^#4afd3e5c8033/ansi_off",
-      "reason": "SELECT (array(1, 2)) ^ 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "^#4b155c91bb5a/ansi_on",
-      "reason": "SELECT 3 ^ (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "^#4b155c91bb5a/ansi_off",
-      "reason": "SELECT 3 ^ (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "^#83d0d49f9f79/ansi_on",
       "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) ^ 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
diff --git a/tests/fixtures/analysis/registry-matrix/%7C.json b/tests/fixtures/analysis/registry-matrix/%7C.json
index 97a3349b5..6d16f46be 100644
--- a/tests/fixtures/analysis/registry-matrix/%7C.json
+++ b/tests/fixtures/analysis/registry-matrix/%7C.json
@@ -16,22 +16,6 @@
       "id": "|#4b4a45b36f81/ansi_off",
       "reason": "SELECT 3 | (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "|#568823444782/ansi_on",
-      "reason": "SELECT (array(1, 2)) | 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "|#568823444782/ansi_off",
-      "reason": "SELECT (array(1, 2)) | 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "|#8c3695b18e5d/ansi_on",
-      "reason": "SELECT 3 | (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "|#8c3695b18e5d/ansi_off",
-      "reason": "SELECT 3 | (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "|#97f196c58d5e/ansi_on",
       "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) | 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
diff --git a/tests/fixtures/analysis/registry-matrix/%7E.json b/tests/fixtures/analysis/registry-matrix/%7E.json
index 26da8ae50..e45f03a64 100644
--- a/tests/fixtures/analysis/registry-matrix/%7E.json
+++ b/tests/fixtures/analysis/registry-matrix/%7E.json
@@ -23,14 +23,6 @@
     {
       "id": "~#645c7912f3f5/ansi_off",
       "reason": "SELECT ~ (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "~#ff628d33811f/ansi_on",
-      "reason": "SELECT ~ (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "~#ff628d33811f/ansi_off",
-      "reason": "SELECT ~ (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/abs.json b/tests/fixtures/analysis/registry-matrix/abs.json
index f83d98d71..8e350c477 100644
--- a/tests/fixtures/analysis/registry-matrix/abs.json
+++ b/tests/fixtures/analysis/registry-matrix/abs.json
@@ -16,14 +16,6 @@
       "id": "abs#259f8171392f/ansi_off",
       "reason": "SELECT abs(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "abs#482fd6fb3fb5/ansi_on",
-      "reason": "SELECT abs(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "abs#482fd6fb3fb5/ansi_off",
-      "reason": "SELECT abs(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "abs#5095fc57b734/ansi_on",
       "reason": "SELECT abs(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/acos.json b/tests/fixtures/analysis/registry-matrix/acos.json
index 672c67a2c..ba719e2b0 100644
--- a/tests/fixtures/analysis/registry-matrix/acos.json
+++ b/tests/fixtures/analysis/registry-matrix/acos.json
@@ -16,14 +16,6 @@
       "id": "acos#646618e3c77a/ansi_off",
       "reason": "SELECT acos(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "acos#87281b46e804/ansi_on",
-      "reason": "SELECT acos(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "acos#87281b46e804/ansi_off",
-      "reason": "SELECT acos(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "acos#d0cfcf8daa8a/ansi_on",
       "reason": "SELECT acos(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/acosh.json b/tests/fixtures/analysis/registry-matrix/acosh.json
index de71997a4..2b926735e 100644
--- a/tests/fixtures/analysis/registry-matrix/acosh.json
+++ b/tests/fixtures/analysis/registry-matrix/acosh.json
@@ -8,14 +8,6 @@
       "id": "acosh#3bee273b22bf/ansi_off",
       "reason": "SELECT acosh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "acosh#5a9d77ca8ad6/ansi_on",
-      "reason": "SELECT acosh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "acosh#5a9d77ca8ad6/ansi_off",
-      "reason": "SELECT acosh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "acosh#82fdddb3781c/ansi_on",
       "reason": "SELECT acosh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/add_months.json b/tests/fixtures/analysis/registry-matrix/add_months.json
index 379db52fb..5f1ac4979 100644
--- a/tests/fixtures/analysis/registry-matrix/add_months.json
+++ b/tests/fixtures/analysis/registry-matrix/add_months.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "add_months#1e08d6e1ace9/ansi_on",
-      "reason": "SELECT add_months(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "add_months#1e08d6e1ace9/ansi_off",
-      "reason": "SELECT add_months(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "add_months#22590bd13694/ansi_on",
       "reason": "SELECT add_months('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -24,14 +16,6 @@
       "id": "add_months#244504d3ba66/ansi_off",
       "reason": "SELECT add_months('2016-08-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "add_months#2e88092bbf13/ansi_on",
-      "reason": "SELECT add_months('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "add_months#2e88092bbf13/ansi_off",
-      "reason": "SELECT add_months('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "add_months#59aa9c148f08/ansi_on",
       "reason": "SELECT add_months(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/any_value.json b/tests/fixtures/analysis/registry-matrix/any_value.json
index 54c040ca5..1043b2469 100644
--- a/tests/fixtures/analysis/registry-matrix/any_value.json
+++ b/tests/fixtures/analysis/registry-matrix/any_value.json
@@ -16,14 +16,6 @@
       "id": "any_value#6188e23671f4/ansi_off",
       "reason": "SELECT any_value(col, map('a', 1)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210"
     },
-    {
-      "id": "any_value#94942fcbfe3e/ansi_on",
-      "reason": "SELECT any_value(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210"
-    },
-    {
-      "id": "any_value#94942fcbfe3e/ansi_off",
-      "reason": "SELECT any_value(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210"
-    },
     {
       "id": "any_value#ba624a02fb3a/ansi_on",
       "reason": "SELECT any_value(col, INTERVAL '1-2' YEAR TO MONTH) FROM VALUES (NULL), (5), (20) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210"
diff --git a/tests/fixtures/analysis/registry-matrix/array.json b/tests/fixtures/analysis/registry-matrix/array.json
new file mode 100644
index 000000000..4ebaa766b
--- /dev/null
+++ b/tests/fixtures/analysis/registry-matrix/array.json
@@ -0,0 +1,78 @@
+{
+  "entries": [
+    {
+      "id": "array#3776c9b2bbb5/ansi_on",
+      "reason": "SELECT array(INTERVAL '1 02:03:04' DAY TO SECOND, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#3776c9b2bbb5/ansi_off",
+      "reason": "SELECT array(INTERVAL '1 02:03:04' DAY TO SECOND, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#3f4eb4621153/ansi_on",
+      "reason": "SELECT array(1, INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#3f4eb4621153/ansi_off",
+      "reason": "SELECT array(1, INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#48fcc0ee45af/ansi_on",
+      "reason": "SELECT array(1, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#48fcc0ee45af/ansi_off",
+      "reason": "SELECT array(1, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#4e48d4c1b9eb/ansi_on",
+      "reason": "SELECT array(1, 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#4e48d4c1b9eb/ansi_off",
+      "reason": "SELECT array(1, 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#56b5cfdc3f32/ansi_on",
+      "reason": "SELECT array(1, INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#56b5cfdc3f32/ansi_off",
+      "reason": "SELECT array(1, INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#9cfb954ccb6e/ansi_on",
+      "reason": "SELECT array(1, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#9cfb954ccb6e/ansi_off",
+      "reason": "SELECT array(1, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#bbc3db311e18/ansi_on",
+      "reason": "SELECT array(map('a', 1), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#bbc3db311e18/ansi_off",
+      "reason": "SELECT array(map('a', 1), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#e4bd5d8105fe/ansi_on",
+      "reason": "SELECT array(1, 2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#e4bd5d8105fe/ansi_off",
+      "reason": "SELECT array(1, 2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#eaa2a4fe5b08/ansi_on",
+      "reason": "SELECT array(INTERVAL '1-2' YEAR TO MONTH, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    },
+    {
+      "id": "array#eaa2a4fe5b08/ansi_off",
+      "reason": "SELECT array(INTERVAL '1-2' YEAR TO MONTH, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+    }
+  ],
+  "format_version": 1,
+  "function": "array"
+}
diff --git a/tests/fixtures/analysis/registry-matrix/ascii.json b/tests/fixtures/analysis/registry-matrix/ascii.json
index 379ea16f9..9fde92f14 100644
--- a/tests/fixtures/analysis/registry-matrix/ascii.json
+++ b/tests/fixtures/analysis/registry-matrix/ascii.json
@@ -8,14 +8,6 @@
       "id": "ascii#013ee5ccb991/ansi_off",
       "reason": "SELECT ascii(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ascii#852318530548/ansi_on",
-      "reason": "SELECT ascii(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ascii#852318530548/ansi_off",
-      "reason": "SELECT ascii(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ascii#a44ca112e769/ansi_on",
       "reason": "SELECT ascii(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/asin.json b/tests/fixtures/analysis/registry-matrix/asin.json
index 6e1807d89..454c57fcf 100644
--- a/tests/fixtures/analysis/registry-matrix/asin.json
+++ b/tests/fixtures/analysis/registry-matrix/asin.json
@@ -23,14 +23,6 @@
     {
       "id": "asin#9782577ff91e/ansi_off",
       "reason": "SELECT asin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "asin#c049095f4686/ansi_on",
-      "reason": "SELECT asin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "asin#c049095f4686/ansi_off",
-      "reason": "SELECT asin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/asinh.json b/tests/fixtures/analysis/registry-matrix/asinh.json
index 86cf74137..b3f4ea37d 100644
--- a/tests/fixtures/analysis/registry-matrix/asinh.json
+++ b/tests/fixtures/analysis/registry-matrix/asinh.json
@@ -8,14 +8,6 @@
       "id": "asinh#46c7e19729ea/ansi_off",
       "reason": "SELECT asinh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "asinh#65a403e1a21d/ansi_on",
-      "reason": "SELECT asinh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "asinh#65a403e1a21d/ansi_off",
-      "reason": "SELECT asinh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "asinh#68bed1327e2a/ansi_on",
       "reason": "SELECT asinh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/assert_true.json b/tests/fixtures/analysis/registry-matrix/assert_true.json
index 0d65318ce..b94544841 100644
--- a/tests/fixtures/analysis/registry-matrix/assert_true.json
+++ b/tests/fixtures/analysis/registry-matrix/assert_true.json
@@ -23,14 +23,6 @@
     {
       "id": "assert_true#ba638b11eda1/ansi_off",
       "reason": "SELECT assert_true(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "assert_true#f08d6b05e52f/ansi_on",
-      "reason": "SELECT assert_true(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "assert_true#f08d6b05e52f/ansi_off",
-      "reason": "SELECT assert_true(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/atan.json b/tests/fixtures/analysis/registry-matrix/atan.json
index ac957f6c8..6489580bb 100644
--- a/tests/fixtures/analysis/registry-matrix/atan.json
+++ b/tests/fixtures/analysis/registry-matrix/atan.json
@@ -23,14 +23,6 @@
     {
       "id": "atan#b9bb1209d291/ansi_off",
       "reason": "SELECT atan(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan#f34317d2890d/ansi_on",
-      "reason": "SELECT atan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan#f34317d2890d/ansi_off",
-      "reason": "SELECT atan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/atan2.json b/tests/fixtures/analysis/registry-matrix/atan2.json
index afffa3e19..fa66ab9be 100644
--- a/tests/fixtures/analysis/registry-matrix/atan2.json
+++ b/tests/fixtures/analysis/registry-matrix/atan2.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "atan2#0cec7ecf11ad/ansi_on",
-      "reason": "SELECT atan2(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan2#0cec7ecf11ad/ansi_off",
-      "reason": "SELECT atan2(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "atan2#4f62ee0e6c22/ansi_on",
       "reason": "SELECT atan2(0, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -55,14 +47,6 @@
     {
       "id": "atan2#ba98c7f801fa/ansi_off",
       "reason": "SELECT atan2(0, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan2#ead386e08f1b/ansi_on",
-      "reason": "SELECT atan2(0, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan2#ead386e08f1b/ansi_off",
-      "reason": "SELECT atan2(0, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/atanh.json b/tests/fixtures/analysis/registry-matrix/atanh.json
index 86377547d..ec5455fa2 100644
--- a/tests/fixtures/analysis/registry-matrix/atanh.json
+++ b/tests/fixtures/analysis/registry-matrix/atanh.json
@@ -23,14 +23,6 @@
     {
       "id": "atanh#8aee7e3f3cdc/ansi_off",
       "reason": "SELECT atanh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atanh#8af9637d5218/ansi_on",
-      "reason": "SELECT atanh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atanh#8af9637d5218/ansi_off",
-      "reason": "SELECT atanh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/base64.json b/tests/fixtures/analysis/registry-matrix/base64.json
index c50835b2f..bb00858bd 100644
--- a/tests/fixtures/analysis/registry-matrix/base64.json
+++ b/tests/fixtures/analysis/registry-matrix/base64.json
@@ -8,14 +8,6 @@
       "id": "base64#1ed5a9f8660a/ansi_off",
       "reason": "SELECT base64(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "base64#b1230e48e360/ansi_on",
-      "reason": "SELECT base64(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "base64#b1230e48e360/ansi_off",
-      "reason": "SELECT base64(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "base64#c00dc50d3002/ansi_on",
       "reason": "SELECT base64(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/bin.json b/tests/fixtures/analysis/registry-matrix/bin.json
index 7ae7dc141..b914b888c 100644
--- a/tests/fixtures/analysis/registry-matrix/bin.json
+++ b/tests/fixtures/analysis/registry-matrix/bin.json
@@ -23,14 +23,6 @@
     {
       "id": "bin#a90cb066faf8/ansi_off",
       "reason": "SELECT bin(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bin#b71e669879a6/ansi_on",
-      "reason": "SELECT bin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bin#b71e669879a6/ansi_off",
-      "reason": "SELECT bin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/bit_count.json b/tests/fixtures/analysis/registry-matrix/bit_count.json
index bc41fff42..f4aeb3908 100644
--- a/tests/fixtures/analysis/registry-matrix/bit_count.json
+++ b/tests/fixtures/analysis/registry-matrix/bit_count.json
@@ -23,14 +23,6 @@
     {
       "id": "bit_count#b49e21523e6e/ansi_off",
       "reason": "SELECT bit_count(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bit_count#dc4f784b72ec/ansi_on",
-      "reason": "SELECT bit_count(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bit_count#dc4f784b72ec/ansi_off",
-      "reason": "SELECT bit_count(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/bit_get.json b/tests/fixtures/analysis/registry-matrix/bit_get.json
index f5362d6da..097128403 100644
--- a/tests/fixtures/analysis/registry-matrix/bit_get.json
+++ b/tests/fixtures/analysis/registry-matrix/bit_get.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "bit_get#09f72caf9f6d/ansi_on",
-      "reason": "SELECT bit_get(11, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bit_get#09f72caf9f6d/ansi_off",
-      "reason": "SELECT bit_get(11, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "bit_get#1cfd4b0fa7e1/ansi_on",
       "reason": "SELECT bit_get(INTERVAL '1-2' YEAR TO MONTH, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,14 +32,6 @@
       "id": "bit_get#9e9ba98e7b02/ansi_off",
       "reason": "SELECT bit_get(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "bit_get#a304d611b3ac/ansi_on",
-      "reason": "SELECT bit_get(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bit_get#a304d611b3ac/ansi_off",
-      "reason": "SELECT bit_get(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "bit_get#ce44b5105527/ansi_on",
       "reason": "SELECT bit_get(11, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/bit_length.json b/tests/fixtures/analysis/registry-matrix/bit_length.json
index 046e2bf13..1133bf35d 100644
--- a/tests/fixtures/analysis/registry-matrix/bit_length.json
+++ b/tests/fixtures/analysis/registry-matrix/bit_length.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "bit_length#4c1a4acd616e/ansi_on",
-      "reason": "SELECT bit_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bit_length#4c1a4acd616e/ansi_off",
-      "reason": "SELECT bit_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "bit_length#79fe889112dd/ansi_on",
       "reason": "SELECT bit_length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/bround.json b/tests/fixtures/analysis/registry-matrix/bround.json
index d3867833b..8b729761a 100644
--- a/tests/fixtures/analysis/registry-matrix/bround.json
+++ b/tests/fixtures/analysis/registry-matrix/bround.json
@@ -16,14 +16,6 @@
       "id": "bround#18b5217d3eff/ansi_off",
       "reason": "SELECT bround(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "bround#6b63892f457c/ansi_on",
-      "reason": "SELECT bround(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bround#6b63892f457c/ansi_off",
-      "reason": "SELECT bround(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "bround#8139bd9fdb4c/ansi_on",
       "reason": "SELECT bround(2.5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -48,14 +40,6 @@
       "id": "bround#972098065b06/ansi_off",
       "reason": "SELECT bround(2.5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "bround#b53e747128fc/ansi_on",
-      "reason": "SELECT bround(2.5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bround#b53e747128fc/ansi_off",
-      "reason": "SELECT bround(2.5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "bround#e536627ae66a/ansi_on",
       "reason": "SELECT bround(2.5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/btrim.json b/tests/fixtures/analysis/registry-matrix/btrim.json
index c1fdb1757..0f75beb13 100644
--- a/tests/fixtures/analysis/registry-matrix/btrim.json
+++ b/tests/fixtures/analysis/registry-matrix/btrim.json
@@ -32,30 +32,6 @@
       "id": "btrim#5a1a560c70c8/ansi_off",
       "reason": "SELECT btrim(INTERVAL '1 02:03:04' DAY TO SECOND, 'SL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "btrim#6f1102cdc0c2/ansi_on",
-      "reason": "SELECT btrim(array(1, 2), 'SL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "btrim#6f1102cdc0c2/ansi_off",
-      "reason": "SELECT btrim(array(1, 2), 'SL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "btrim#712992317d38/ansi_on",
-      "reason": "SELECT btrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "btrim#712992317d38/ansi_off",
-      "reason": "SELECT btrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "btrim#71e5a8cb22b3/ansi_on",
-      "reason": "SELECT btrim('SSparkSQLS', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "btrim#71e5a8cb22b3/ansi_off",
-      "reason": "SELECT btrim('SSparkSQLS', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "btrim#812b69ba8fda/ansi_on",
       "reason": "SELECT btrim('SSparkSQLS', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/cbrt.json b/tests/fixtures/analysis/registry-matrix/cbrt.json
index e25ba1378..c66e34d42 100644
--- a/tests/fixtures/analysis/registry-matrix/cbrt.json
+++ b/tests/fixtures/analysis/registry-matrix/cbrt.json
@@ -16,14 +16,6 @@
       "id": "cbrt#73c4fc1e92b9/ansi_off",
       "reason": "SELECT cbrt(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "cbrt#b0ead4e731f4/ansi_on",
-      "reason": "SELECT cbrt(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cbrt#b0ead4e731f4/ansi_off",
-      "reason": "SELECT cbrt(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "cbrt#fdb007bf9143/ansi_on",
       "reason": "SELECT cbrt(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/ceil.json b/tests/fixtures/analysis/registry-matrix/ceil.json
index f4fbbf7da..5f181e547 100644
--- a/tests/fixtures/analysis/registry-matrix/ceil.json
+++ b/tests/fixtures/analysis/registry-matrix/ceil.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "ceil#2f7b08117092/ansi_on",
-      "reason": "SELECT ceil(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "ceil#2f7b08117092/ansi_off",
-      "reason": "SELECT ceil(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT"
-    },
     {
       "id": "ceil#4ca9bc16d90d/ansi_on",
       "reason": "SELECT ceil(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -32,14 +24,6 @@
       "id": "ceil#5b3a37a449f4/ansi_off",
       "reason": "SELECT ceil(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ceil#68dccc710861/ansi_on",
-      "reason": "SELECT ceil(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceil#68dccc710861/ansi_off",
-      "reason": "SELECT ceil(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ceil#bb23a5bd68bf/ansi_on",
       "reason": "SELECT ceil(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -64,14 +48,6 @@
       "id": "ceil#ca364ac004a2/ansi_off",
       "reason": "SELECT ceil(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ceil#e8617ac2cc62/ansi_on",
-      "reason": "SELECT ceil(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceil#e8617ac2cc62/ansi_off",
-      "reason": "SELECT ceil(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ceil#ead4d6922dcb/ansi_on",
       "reason": "SELECT ceil(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/ceiling.json b/tests/fixtures/analysis/registry-matrix/ceiling.json
index 9a3982a3b..a55a9367c 100644
--- a/tests/fixtures/analysis/registry-matrix/ceiling.json
+++ b/tests/fixtures/analysis/registry-matrix/ceiling.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "ceiling#20bc43388a99/ansi_on",
-      "reason": "SELECT ceiling(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceiling#20bc43388a99/ansi_off",
-      "reason": "SELECT ceiling(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ceiling#3d5f6ac925b9/ansi_on",
       "reason": "SELECT ceiling(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -24,14 +16,6 @@
       "id": "ceiling#523bf03f299a/ansi_off",
       "reason": "SELECT ceiling(3.1411, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has NON_FOLDABLE_ARGUMENT"
     },
-    {
-      "id": "ceiling#63e6ed7b8d9f/ansi_on",
-      "reason": "SELECT ceiling(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceiling#63e6ed7b8d9f/ansi_off",
-      "reason": "SELECT ceiling(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ceiling#6bd7751202b6/ansi_on",
       "reason": "SELECT ceiling(3.1411, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has NON_FOLDABLE_ARGUMENT"
@@ -64,14 +48,6 @@
       "id": "ceiling#c2037689a057/ansi_off",
       "reason": "SELECT ceiling(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ceiling#edc642c068e1/ansi_on",
-      "reason": "SELECT ceiling(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "ceiling#edc642c068e1/ansi_off",
-      "reason": "SELECT ceiling(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT"
-    },
     {
       "id": "ceiling#f4a8508a15c7/ansi_on",
       "reason": "SELECT ceiling(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/char.json b/tests/fixtures/analysis/registry-matrix/char.json
index 98c5b14cc..8320612b7 100644
--- a/tests/fixtures/analysis/registry-matrix/char.json
+++ b/tests/fixtures/analysis/registry-matrix/char.json
@@ -23,14 +23,6 @@
     {
       "id": "char#c1b5db0c04de/ansi_off",
       "reason": "SELECT char(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "char#eec277f32bd5/ansi_on",
-      "reason": "SELECT char(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "char#eec277f32bd5/ansi_off",
-      "reason": "SELECT char(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/char_length.json b/tests/fixtures/analysis/registry-matrix/char_length.json
index ef6e053a4..f8ba9cbbf 100644
--- a/tests/fixtures/analysis/registry-matrix/char_length.json
+++ b/tests/fixtures/analysis/registry-matrix/char_length.json
@@ -16,14 +16,6 @@
       "id": "char_length#51c55d351a74/ansi_off",
       "reason": "SELECT char_length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "char_length#5ae2fd4ad7df/ansi_on",
-      "reason": "SELECT char_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "char_length#5ae2fd4ad7df/ansi_off",
-      "reason": "SELECT char_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "char_length#f6d2d8a18a6b/ansi_on",
       "reason": "SELECT char_length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/character_length.json b/tests/fixtures/analysis/registry-matrix/character_length.json
index c37c92498..b53efa045 100644
--- a/tests/fixtures/analysis/registry-matrix/character_length.json
+++ b/tests/fixtures/analysis/registry-matrix/character_length.json
@@ -23,14 +23,6 @@
     {
       "id": "character_length#86662ee970bb/ansi_off",
       "reason": "SELECT character_length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "character_length#9ab7c3b48505/ansi_on",
-      "reason": "SELECT character_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "character_length#9ab7c3b48505/ansi_off",
-      "reason": "SELECT character_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/chr.json b/tests/fixtures/analysis/registry-matrix/chr.json
index f5f252511..9a01e2b87 100644
--- a/tests/fixtures/analysis/registry-matrix/chr.json
+++ b/tests/fixtures/analysis/registry-matrix/chr.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "chr#5a05d55b7650/ansi_on",
-      "reason": "SELECT chr(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "chr#5a05d55b7650/ansi_off",
-      "reason": "SELECT chr(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "chr#701f944ff7a9/ansi_on",
       "reason": "SELECT chr(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/coalesce.json b/tests/fixtures/analysis/registry-matrix/coalesce.json
index d2b3bbc7c..2586d0eb0 100644
--- a/tests/fixtures/analysis/registry-matrix/coalesce.json
+++ b/tests/fixtures/analysis/registry-matrix/coalesce.json
@@ -16,14 +16,6 @@
       "id": "coalesce#31842a9dbd4d/ansi_off",
       "reason": "SELECT coalesce(NULL, INTERVAL '1 02:03:04' DAY TO SECOND, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "coalesce#3297ad75dfb5/ansi_on",
-      "reason": "SELECT coalesce(array(1, 2), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "coalesce#3297ad75dfb5/ansi_off",
-      "reason": "SELECT coalesce(array(1, 2), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "coalesce#58920259386f/ansi_on",
       "reason": "SELECT coalesce(map('a', 1), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -56,14 +48,6 @@
       "id": "coalesce#6b6547c1b6c0/ansi_off",
       "reason": "SELECT coalesce(INTERVAL '1 02:03:04' DAY TO SECOND, 1, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "coalesce#8b4e6c6ee9e8/ansi_on",
-      "reason": "SELECT coalesce(NULL, array(1, 2), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "coalesce#8b4e6c6ee9e8/ansi_off",
-      "reason": "SELECT coalesce(NULL, array(1, 2), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "coalesce#a8ec93040e68/ansi_on",
       "reason": "SELECT coalesce(INTERVAL '1-2' YEAR TO MONTH, 1, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -80,14 +64,6 @@
       "id": "coalesce#ad0be0bee7ac/ansi_off",
       "reason": "SELECT coalesce(NULL, 1, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "coalesce#afa62deb2dc3/ansi_on",
-      "reason": "SELECT coalesce(NULL, 1, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "coalesce#afa62deb2dc3/ansi_off",
-      "reason": "SELECT coalesce(NULL, 1, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "coalesce#c5de409dc37c/ansi_on",
       "reason": "SELECT coalesce(NULL, 1, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
diff --git a/tests/fixtures/analysis/registry-matrix/concat_ws.json b/tests/fixtures/analysis/registry-matrix/concat_ws.json
index 0ce976d06..4ba5b01d0 100644
--- a/tests/fixtures/analysis/registry-matrix/concat_ws.json
+++ b/tests/fixtures/analysis/registry-matrix/concat_ws.json
@@ -2,19 +2,19 @@
   "entries": [
     {
       "id": "concat_ws#05e80bea960a/ansi_on",
-      "reason": "SELECT concat_ws(' ', 'Spark', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT concat_ws(' ', 'Spark', array(1, 2)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "concat_ws#05e80bea960a/ansi_off",
-      "reason": "SELECT concat_ws(' ', 'Spark', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT concat_ws(' ', 'Spark', array(1, 2)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "concat_ws#0f4e2555c55a/ansi_on",
-      "reason": "SELECT concat_ws('/', 'foo', array(1, 2), 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT concat_ws('/', 'foo', array(1, 2), 'bar') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "concat_ws#0f4e2555c55a/ansi_off",
-      "reason": "SELECT concat_ws('/', 'foo', array(1, 2), 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT concat_ws('/', 'foo', array(1, 2), 'bar') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "concat_ws#1b15aa4fe439/ansi_on",
@@ -58,11 +58,11 @@
     },
     {
       "id": "concat_ws#25e479259845/ansi_on",
-      "reason": "SELECT concat_ws('/', array(1, 2), null, 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT concat_ws('/', array(1, 2), null, 'bar') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "concat_ws#25e479259845/ansi_off",
-      "reason": "SELECT concat_ws('/', array(1, 2), null, 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT concat_ws('/', array(1, 2), null, 'bar') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "concat_ws#2616ec8f1364/ansi_on",
@@ -88,14 +88,6 @@
       "id": "concat_ws#36558275390c/ansi_off",
       "reason": "SELECT concat_ws(' ', INTERVAL '1 02:03:04' DAY TO SECOND, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "concat_ws#46ee656eee52/ansi_on",
-      "reason": "SELECT concat_ws(array(1, 2), 'foo', null, 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "concat_ws#46ee656eee52/ansi_off",
-      "reason": "SELECT concat_ws(array(1, 2), 'foo', null, 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "concat_ws#4a51a9f372e8/ansi_on",
       "reason": "SELECT concat_ws('/', 'foo', INTERVAL '1 02:03:04' DAY TO SECOND, 'bar') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -128,14 +120,6 @@
       "id": "concat_ws#6ab0510eaa1f/ansi_off",
       "reason": "SELECT concat_ws(INTERVAL '1 02:03:04' DAY TO SECOND, 'Spark', 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "concat_ws#6ec143f5d2bf/ansi_on",
-      "reason": "SELECT concat_ws(array(1, 2), 'Spark', 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "concat_ws#6ec143f5d2bf/ansi_off",
-      "reason": "SELECT concat_ws(array(1, 2), 'Spark', 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "concat_ws#7029d64723a3/ansi_on",
       "reason": "SELECT concat_ws('/', 'foo', map('a', 1), 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -186,11 +170,11 @@
     },
     {
       "id": "concat_ws#b38eed07ec95/ansi_on",
-      "reason": "SELECT concat_ws(' ', array(1, 2), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT concat_ws(' ', array(1, 2), 'SQL') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "concat_ws#b38eed07ec95/ansi_off",
-      "reason": "SELECT concat_ws(' ', array(1, 2), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT concat_ws(' ', array(1, 2), 'SQL') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "concat_ws#bbb2b8b9fa31/ansi_on",
@@ -234,19 +218,11 @@
     },
     {
       "id": "concat_ws#dd860c605aab/ansi_on",
-      "reason": "SELECT concat_ws('/', 'foo', null, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT concat_ws('/', 'foo', null, array(1, 2)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "concat_ws#dd860c605aab/ansi_off",
-      "reason": "SELECT concat_ws('/', 'foo', null, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "concat_ws#e36ae892bd1e/ansi_on",
-      "reason": "SELECT concat_ws(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "concat_ws#e36ae892bd1e/ansi_off",
-      "reason": "SELECT concat_ws(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT concat_ws('/', 'foo', null, array(1, 2)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "concat_ws#eb7e37628cc8/ansi_on",
diff --git a/tests/fixtures/analysis/registry-matrix/contains.json b/tests/fixtures/analysis/registry-matrix/contains.json
index 5fe414f15..70fef4f2b 100644
--- a/tests/fixtures/analysis/registry-matrix/contains.json
+++ b/tests/fixtures/analysis/registry-matrix/contains.json
@@ -32,22 +32,6 @@
       "id": "contains#6c826c84c7a4/ansi_off",
       "reason": "SELECT contains(INTERVAL '1-2' YEAR TO MONTH, 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "contains#a2d830b27abd/ansi_on",
-      "reason": "SELECT contains('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "contains#a2d830b27abd/ansi_off",
-      "reason": "SELECT contains('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "contains#c94bfd9f0f0a/ansi_on",
-      "reason": "SELECT contains(array(1, 2), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "contains#c94bfd9f0f0a/ansi_off",
-      "reason": "SELECT contains(array(1, 2), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "contains#d7f2b5dd724d/ansi_on",
       "reason": "SELECT contains('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/conv.json b/tests/fixtures/analysis/registry-matrix/conv.json
index 7408fe8ea..5c4f63d72 100644
--- a/tests/fixtures/analysis/registry-matrix/conv.json
+++ b/tests/fixtures/analysis/registry-matrix/conv.json
@@ -16,14 +16,6 @@
       "id": "conv#7461c93e555c/ansi_off",
       "reason": "SELECT conv(INTERVAL '1 02:03:04' DAY TO SECOND, 2, 10) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "conv#7a657a811c87/ansi_on",
-      "reason": "SELECT conv(array(1, 2), 2, 10) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "conv#7a657a811c87/ansi_off",
-      "reason": "SELECT conv(array(1, 2), 2, 10) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "conv#81a1f2194627/ansi_on",
       "reason": "SELECT conv('100', INTERVAL '1-2' YEAR TO MONTH, 10) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -64,14 +56,6 @@
       "id": "conv#94a8f88df66a/ansi_off",
       "reason": "SELECT conv('100', 2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "conv#99e8cdec0d93/ansi_on",
-      "reason": "SELECT conv('100', array(1, 2), 10) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "conv#99e8cdec0d93/ansi_off",
-      "reason": "SELECT conv('100', array(1, 2), 10) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "conv#bb384aabc1fa/ansi_on",
       "reason": "SELECT conv('100', 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -87,14 +71,6 @@
     {
       "id": "conv#c45bee861796/ansi_off",
       "reason": "SELECT conv(map('a', 1), 2, 10) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "conv#ec214d3068bf/ansi_on",
-      "reason": "SELECT conv('100', 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "conv#ec214d3068bf/ansi_off",
-      "reason": "SELECT conv('100', 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/convert_timezone.json b/tests/fixtures/analysis/registry-matrix/convert_timezone.json
index 570e0ca25..c55a4b9e5 100644
--- a/tests/fixtures/analysis/registry-matrix/convert_timezone.json
+++ b/tests/fixtures/analysis/registry-matrix/convert_timezone.json
@@ -8,22 +8,6 @@
       "id": "convert_timezone#147a06c5b92b/ansi_off",
       "reason": "SELECT convert_timezone(INTERVAL '1-2' YEAR TO MONTH, timestamp_ntz'2021-12-05 15:00:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "convert_timezone#17ebeac38975/ansi_on",
-      "reason": "SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "convert_timezone#17ebeac38975/ansi_off",
-      "reason": "SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "convert_timezone#1de7cd4cc6a8/ansi_on",
-      "reason": "SELECT convert_timezone(array(1, 2), timestamp_ntz'2021-12-05 15:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "convert_timezone#1de7cd4cc6a8/ansi_off",
-      "reason": "SELECT convert_timezone(array(1, 2), timestamp_ntz'2021-12-05 15:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "convert_timezone#2661b7e18ccc/ansi_on",
       "reason": "SELECT convert_timezone(INTERVAL '1 02:03:04' DAY TO SECOND, 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -56,14 +40,6 @@
       "id": "convert_timezone#4b75798678ba/ansi_off",
       "reason": "SELECT convert_timezone('Europe/Brussels', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "convert_timezone#51a54a73ab9d/ansi_on",
-      "reason": "SELECT convert_timezone('Europe/Brussels', array(1, 2), timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "convert_timezone#51a54a73ab9d/ansi_off",
-      "reason": "SELECT convert_timezone('Europe/Brussels', array(1, 2), timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "convert_timezone#5a82d191b61f/ansi_on",
       "reason": "SELECT convert_timezone(map('a', 1), timestamp_ntz'2021-12-05 15:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -120,14 +96,6 @@
       "id": "convert_timezone#b0dd48f6ba13/ansi_off",
       "reason": "SELECT convert_timezone('Europe/Brussels', INTERVAL '1-2' YEAR TO MONTH, timestamp_ntz'2021-12-06 00:00:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "convert_timezone#b3dc648c2fdf/ansi_on",
-      "reason": "SELECT convert_timezone('Europe/Brussels', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "convert_timezone#b3dc648c2fdf/ansi_off",
-      "reason": "SELECT convert_timezone('Europe/Brussels', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "convert_timezone#cc1eb2d7ea80/ansi_on",
       "reason": "SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -144,14 +112,6 @@
       "id": "convert_timezone#d074d150b0ec/ansi_off",
       "reason": "SELECT convert_timezone(INTERVAL '1-2' YEAR TO MONTH, 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "convert_timezone#f585af0294f1/ansi_on",
-      "reason": "SELECT convert_timezone(array(1, 2), 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "convert_timezone#f585af0294f1/ansi_off",
-      "reason": "SELECT convert_timezone(array(1, 2), 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "convert_timezone#f9774a50969a/ansi_on",
       "reason": "SELECT convert_timezone('Europe/Brussels', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/cos.json b/tests/fixtures/analysis/registry-matrix/cos.json
index a5c902703..4fd04dff5 100644
--- a/tests/fixtures/analysis/registry-matrix/cos.json
+++ b/tests/fixtures/analysis/registry-matrix/cos.json
@@ -23,14 +23,6 @@
     {
       "id": "cos#6e49e17c44c6/ansi_off",
       "reason": "SELECT cos(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cos#d8a37c57177c/ansi_on",
-      "reason": "SELECT cos(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cos#d8a37c57177c/ansi_off",
-      "reason": "SELECT cos(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/cosh.json b/tests/fixtures/analysis/registry-matrix/cosh.json
index b55a3f695..210f6f7d7 100644
--- a/tests/fixtures/analysis/registry-matrix/cosh.json
+++ b/tests/fixtures/analysis/registry-matrix/cosh.json
@@ -8,14 +8,6 @@
       "id": "cosh#19241e43181f/ansi_off",
       "reason": "SELECT cosh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "cosh#237a92894fe4/ansi_on",
-      "reason": "SELECT cosh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cosh#237a92894fe4/ansi_off",
-      "reason": "SELECT cosh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "cosh#43b9893c0613/ansi_on",
       "reason": "SELECT cosh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/cot.json b/tests/fixtures/analysis/registry-matrix/cot.json
index 140d0ab63..a319e5ced 100644
--- a/tests/fixtures/analysis/registry-matrix/cot.json
+++ b/tests/fixtures/analysis/registry-matrix/cot.json
@@ -8,14 +8,6 @@
       "id": "cot#8ce11c7a7b63/ansi_off",
       "reason": "SELECT cot(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "cot#c525cd60d93f/ansi_on",
-      "reason": "SELECT cot(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cot#c525cd60d93f/ansi_off",
-      "reason": "SELECT cot(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "cot#d332d357b677/ansi_on",
       "reason": "SELECT cot(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/crc32.json b/tests/fixtures/analysis/registry-matrix/crc32.json
index 96bec0d3a..2a65153c9 100644
--- a/tests/fixtures/analysis/registry-matrix/crc32.json
+++ b/tests/fixtures/analysis/registry-matrix/crc32.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "crc32#2651371c29d2/ansi_on",
-      "reason": "SELECT crc32(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "crc32#2651371c29d2/ansi_off",
-      "reason": "SELECT crc32(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "crc32#4f1001de936c/ansi_on",
       "reason": "SELECT crc32(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/csc.json b/tests/fixtures/analysis/registry-matrix/csc.json
index dd4db90c2..a8b6d1baa 100644
--- a/tests/fixtures/analysis/registry-matrix/csc.json
+++ b/tests/fixtures/analysis/registry-matrix/csc.json
@@ -16,14 +16,6 @@
       "id": "csc#9a00661998eb/ansi_off",
       "reason": "SELECT csc(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "csc#adfe5d6693e0/ansi_on",
-      "reason": "SELECT csc(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "csc#adfe5d6693e0/ansi_off",
-      "reason": "SELECT csc(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "csc#ec3407fe091a/ansi_on",
       "reason": "SELECT csc(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/date_add.json b/tests/fixtures/analysis/registry-matrix/date_add.json
index 817bf5919..245c2a5d9 100644
--- a/tests/fixtures/analysis/registry-matrix/date_add.json
+++ b/tests/fixtures/analysis/registry-matrix/date_add.json
@@ -32,14 +32,6 @@
       "id": "date_add#a2161f5ef3fc/ansi_off",
       "reason": "SELECT date_add(INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_add#a8f6b473b026/ansi_on",
-      "reason": "SELECT date_add('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_add#a8f6b473b026/ansi_off",
-      "reason": "SELECT date_add('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "date_add#f23843967997/ansi_on",
       "reason": "SELECT date_add('2016-07-30', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -48,14 +40,6 @@
       "id": "date_add#f23843967997/ansi_off",
       "reason": "SELECT date_add('2016-07-30', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_add#f3fabb0301c9/ansi_on",
-      "reason": "SELECT date_add(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_add#f3fabb0301c9/ansi_off",
-      "reason": "SELECT date_add(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "date_add#fad633c93567/ansi_on",
       "reason": "SELECT date_add('2016-07-30', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/date_diff.json b/tests/fixtures/analysis/registry-matrix/date_diff.json
index adfd5878d..a3ae33668 100644
--- a/tests/fixtures/analysis/registry-matrix/date_diff.json
+++ b/tests/fixtures/analysis/registry-matrix/date_diff.json
@@ -8,14 +8,6 @@
       "id": "date_diff#05942e933fcc/ansi_off",
       "reason": "SELECT date_diff(map('a', 1), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_diff#06d2c47693d1/ansi_on",
-      "reason": "SELECT date_diff(array(1, 2), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_diff#06d2c47693d1/ansi_off",
-      "reason": "SELECT date_diff(array(1, 2), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "date_diff#13970b9a8111/ansi_on",
       "reason": "SELECT date_diff(INTERVAL '1-2' YEAR TO MONTH, '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,14 +32,6 @@
       "id": "date_diff#551ef3d9f510/ansi_off",
       "reason": "SELECT date_diff('2009-07-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_diff#59223d845876/ansi_on",
-      "reason": "SELECT date_diff('2009-07-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_diff#59223d845876/ansi_off",
-      "reason": "SELECT date_diff('2009-07-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "date_diff#9afec0436340/ansi_on",
       "reason": "SELECT date_diff('2009-07-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/date_part.json b/tests/fixtures/analysis/registry-matrix/date_part.json
index 3f054c766..062179a6f 100644
--- a/tests/fixtures/analysis/registry-matrix/date_part.json
+++ b/tests/fixtures/analysis/registry-matrix/date_part.json
@@ -48,14 +48,6 @@
       "id": "date_part#636c907f859b/ansi_off",
       "reason": "SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "date_part#7bb6e029aba1/ansi_on",
-      "reason": "SELECT date_part('YEAR', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_part#7bb6e029aba1/ansi_off",
-      "reason": "SELECT date_part('YEAR', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "date_part#a7d2bff3fe87/ansi_on",
       "reason": "SELECT date_part('days', interval 5 days 3 hours 7 minutes) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -74,11 +66,11 @@
     },
     {
       "id": "date_part#aee6337cfd66/ansi_on",
-      "reason": "SELECT date_part(array(1, 2), TIMESTAMP '2019-08-12 01:00:00.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT"
+      "reason": "SELECT date_part(array(1, 2), TIMESTAMP '2019-08-12 01:00:00.123456') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has NON_FOLDABLE_ARGUMENT"
     },
     {
       "id": "date_part#aee6337cfd66/ansi_off",
-      "reason": "SELECT date_part(array(1, 2), TIMESTAMP '2019-08-12 01:00:00.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT"
+      "reason": "SELECT date_part(array(1, 2), TIMESTAMP '2019-08-12 01:00:00.123456') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has NON_FOLDABLE_ARGUMENT"
     },
     {
       "id": "date_part#b27dc92b308a/ansi_on",
diff --git a/tests/fixtures/analysis/registry-matrix/date_sub.json b/tests/fixtures/analysis/registry-matrix/date_sub.json
index 53b6ea22a..729bec07e 100644
--- a/tests/fixtures/analysis/registry-matrix/date_sub.json
+++ b/tests/fixtures/analysis/registry-matrix/date_sub.json
@@ -8,14 +8,6 @@
       "id": "date_sub#71cca371ad5a/ansi_off",
       "reason": "SELECT date_sub('2016-07-30', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_sub#a24ef0a9b5b8/ansi_on",
-      "reason": "SELECT date_sub(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_sub#a24ef0a9b5b8/ansi_off",
-      "reason": "SELECT date_sub(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "date_sub#adae19b649ad/ansi_on",
       "reason": "SELECT date_sub(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -32,14 +24,6 @@
       "id": "date_sub#b39d32775713/ansi_off",
       "reason": "SELECT date_sub(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_sub#c2416e1a06e9/ansi_on",
-      "reason": "SELECT date_sub('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_sub#c2416e1a06e9/ansi_off",
-      "reason": "SELECT date_sub('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "date_sub#c296eaac697f/ansi_on",
       "reason": "SELECT date_sub('2016-07-30', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/date_trunc.json b/tests/fixtures/analysis/registry-matrix/date_trunc.json
index dea8a0b50..aee9b50b5 100644
--- a/tests/fixtures/analysis/registry-matrix/date_trunc.json
+++ b/tests/fixtures/analysis/registry-matrix/date_trunc.json
@@ -16,14 +16,6 @@
       "id": "date_trunc#667578cd1810/ansi_off",
       "reason": "SELECT date_trunc('YEAR', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_trunc#939c9dd369ab/ansi_on",
-      "reason": "SELECT date_trunc(array(1, 2), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_trunc#939c9dd369ab/ansi_off",
-      "reason": "SELECT date_trunc(array(1, 2), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "date_trunc#ab8944d5b81e/ansi_on",
       "reason": "SELECT date_trunc(map('a', 1), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -32,14 +24,6 @@
       "id": "date_trunc#ab8944d5b81e/ansi_off",
       "reason": "SELECT date_trunc(map('a', 1), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_trunc#b60f1d3d4024/ansi_on",
-      "reason": "SELECT date_trunc('YEAR', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_trunc#b60f1d3d4024/ansi_off",
-      "reason": "SELECT date_trunc('YEAR', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "date_trunc#bbab69ebe047/ansi_on",
       "reason": "SELECT date_trunc(INTERVAL '1 02:03:04' DAY TO SECOND, '2015-03-05T09:32:05.359') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/dateadd.json b/tests/fixtures/analysis/registry-matrix/dateadd.json
index 0e905d6a3..361aa2aae 100644
--- a/tests/fixtures/analysis/registry-matrix/dateadd.json
+++ b/tests/fixtures/analysis/registry-matrix/dateadd.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "dateadd#1db53f156b77/ansi_on",
-      "reason": "SELECT dateadd('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "dateadd#1db53f156b77/ansi_off",
-      "reason": "SELECT dateadd('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "dateadd#207a6a5ed88a/ansi_on",
       "reason": "SELECT dateadd(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -16,14 +8,6 @@
       "id": "dateadd#207a6a5ed88a/ansi_off",
       "reason": "SELECT dateadd(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "dateadd#54c3fbb83814/ansi_on",
-      "reason": "SELECT dateadd(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "dateadd#54c3fbb83814/ansi_off",
-      "reason": "SELECT dateadd(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "dateadd#63408c53af98/ansi_on",
       "reason": "SELECT dateadd(INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/datediff.json b/tests/fixtures/analysis/registry-matrix/datediff.json
index a49e3f031..854813384 100644
--- a/tests/fixtures/analysis/registry-matrix/datediff.json
+++ b/tests/fixtures/analysis/registry-matrix/datediff.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "datediff#18d30bab86bf/ansi_on",
-      "reason": "SELECT datediff(array(1, 2), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "datediff#18d30bab86bf/ansi_off",
-      "reason": "SELECT datediff(array(1, 2), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "datediff#1ada08a843e8/ansi_on",
       "reason": "SELECT datediff('2009-07-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -55,14 +47,6 @@
     {
       "id": "datediff#9191f9843b3d/ansi_off",
       "reason": "SELECT datediff(INTERVAL '1 02:03:04' DAY TO SECOND, '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "datediff#95d5a3cc05e6/ansi_on",
-      "reason": "SELECT datediff('2009-07-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "datediff#95d5a3cc05e6/ansi_off",
-      "reason": "SELECT datediff('2009-07-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/day.json b/tests/fixtures/analysis/registry-matrix/day.json
index 0d14a119a..91c8a1913 100644
--- a/tests/fixtures/analysis/registry-matrix/day.json
+++ b/tests/fixtures/analysis/registry-matrix/day.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "day#6ec736886dac/ansi_on",
-      "reason": "SELECT day(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "day#6ec736886dac/ansi_off",
-      "reason": "SELECT day(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "day#c5006e6a3413/ansi_on",
       "reason": "SELECT day(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/dayname.json b/tests/fixtures/analysis/registry-matrix/dayname.json
index 7111a604f..d39bc58de 100644
--- a/tests/fixtures/analysis/registry-matrix/dayname.json
+++ b/tests/fixtures/analysis/registry-matrix/dayname.json
@@ -31,14 +31,6 @@
     {
       "id": "dayname#cd6ab24d7543/ansi_off",
       "reason": "SELECT dayname(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "dayname#d33c54efcf10/ansi_on",
-      "reason": "SELECT dayname(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "dayname#d33c54efcf10/ansi_off",
-      "reason": "SELECT dayname(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/dayofmonth.json b/tests/fixtures/analysis/registry-matrix/dayofmonth.json
index 53fff3fb7..4f48188c2 100644
--- a/tests/fixtures/analysis/registry-matrix/dayofmonth.json
+++ b/tests/fixtures/analysis/registry-matrix/dayofmonth.json
@@ -8,14 +8,6 @@
       "id": "dayofmonth#0296012a73bf/ansi_off",
       "reason": "SELECT dayofmonth(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "dayofmonth#039eeb4f3b46/ansi_on",
-      "reason": "SELECT dayofmonth(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "dayofmonth#039eeb4f3b46/ansi_off",
-      "reason": "SELECT dayofmonth(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "dayofmonth#63cbd5ac0445/ansi_on",
       "reason": "SELECT dayofmonth(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/dayofweek.json b/tests/fixtures/analysis/registry-matrix/dayofweek.json
index cc9a7c764..b68dc7720 100644
--- a/tests/fixtures/analysis/registry-matrix/dayofweek.json
+++ b/tests/fixtures/analysis/registry-matrix/dayofweek.json
@@ -23,14 +23,6 @@
     {
       "id": "dayofweek#b213f42da8ee/ansi_off",
       "reason": "SELECT dayofweek(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "dayofweek#cb4a7b0f9f60/ansi_on",
-      "reason": "SELECT dayofweek(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "dayofweek#cb4a7b0f9f60/ansi_off",
-      "reason": "SELECT dayofweek(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/dayofyear.json b/tests/fixtures/analysis/registry-matrix/dayofyear.json
index cf5cc7dfe..91b7dee02 100644
--- a/tests/fixtures/analysis/registry-matrix/dayofyear.json
+++ b/tests/fixtures/analysis/registry-matrix/dayofyear.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "dayofyear#6b1828e51769/ansi_on",
-      "reason": "SELECT dayofyear(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "dayofyear#6b1828e51769/ansi_off",
-      "reason": "SELECT dayofyear(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "dayofyear#8545d9aa0c51/ansi_on",
       "reason": "SELECT dayofyear(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/decode.json b/tests/fixtures/analysis/registry-matrix/decode.json
index 78f914bf8..05df015f1 100644
--- a/tests/fixtures/analysis/registry-matrix/decode.json
+++ b/tests/fixtures/analysis/registry-matrix/decode.json
@@ -50,11 +50,11 @@
     },
     {
       "id": "decode#026a11b2172b/ansi_on",
-      "reason": "SELECT decode(null, array(1, 2), 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT decode(null, array(1, 2), 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments"
     },
     {
       "id": "decode#026a11b2172b/ansi_off",
-      "reason": "SELECT decode(null, array(1, 2), 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT decode(null, array(1, 2), 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments"
     },
     {
       "id": "decode#02dcecbca7c9/ansi_on",
@@ -154,11 +154,11 @@
     },
     {
       "id": "decode#07a4a37224f3/ansi_on",
-      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', array(1, 2), 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', array(1, 2), 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#07a4a37224f3/ansi_off",
-      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', array(1, 2), 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', array(1, 2), 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#07bbaaea4a70/ansi_on",
@@ -354,11 +354,11 @@
     },
     {
       "id": "decode#0fc8598e60c5/ansi_on",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, array(1, 2), 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, array(1, 2), 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#0fc8598e60c5/ansi_off",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, array(1, 2), 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, array(1, 2), 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#103c812d0dee/ansi_on",
@@ -450,19 +450,11 @@
     },
     {
       "id": "decode#14b6a9c78eee/ansi_on",
-      "reason": "SELECT decode(6, 1, 'Southlake', array(1, 2), 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', array(1, 2), 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#14b6a9c78eee/ansi_off",
-      "reason": "SELECT decode(6, 1, 'Southlake', array(1, 2), 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "decode#14d4e8af3e77/ansi_on",
-      "reason": "SELECT decode(encode('abc', 'utf-8'), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "decode#14d4e8af3e77/ansi_off",
-      "reason": "SELECT decode(encode('abc', 'utf-8'), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT decode(6, 1, 'Southlake', array(1, 2), 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#14f0de0a21fd/ansi_on",
@@ -610,11 +602,11 @@
     },
     {
       "id": "decode#1d0206da8bb6/ansi_on",
-      "reason": "SELECT decode(array(1, 2), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(array(1, 2), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#1d0206da8bb6/ansi_off",
-      "reason": "SELECT decode(array(1, 2), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(array(1, 2), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#1d4a59814371/ansi_on",
@@ -904,14 +896,6 @@
       "id": "decode#2b7b9c9ad4be/ansi_off",
       "reason": "SELECT decode(null, 1.5D, 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments"
     },
-    {
-      "id": "decode#2b810f12e5ee/ansi_on",
-      "reason": "SELECT decode(array(1, 2), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "decode#2b810f12e5ee/ansi_off",
-      "reason": "SELECT decode(array(1, 2), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "decode#2ba79b6c8a55/ansi_on",
       "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -954,11 +938,11 @@
     },
     {
       "id": "decode#2de80affd3f1/ansi_on",
-      "reason": "SELECT decode(array(1, 2), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(array(1, 2), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#2de80affd3f1/ansi_off",
-      "reason": "SELECT decode(array(1, 2), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(array(1, 2), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#2e6beb46f788/ansi_on",
@@ -1138,11 +1122,11 @@
     },
     {
       "id": "decode#37968d97daf1/ansi_on",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', array(1, 2), 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', array(1, 2), 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#37968d97daf1/ansi_off",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', array(1, 2), 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', array(1, 2), 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#3844592d7e08/ansi_on",
@@ -1722,11 +1706,11 @@
     },
     {
       "id": "decode#52948e882166/ansi_on",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, array(1, 2), 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, array(1, 2), 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#52948e882166/ansi_off",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, array(1, 2), 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, array(1, 2), 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#52b986b20217/ansi_on",
@@ -1778,11 +1762,11 @@
     },
     {
       "id": "decode#54377efb807a/ansi_on",
-      "reason": "SELECT decode(6, 1, array(1, 2), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, array(1, 2), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#54377efb807a/ansi_off",
-      "reason": "SELECT decode(6, 1, array(1, 2), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, array(1, 2), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#5496d9b04287/ansi_on",
@@ -1794,11 +1778,11 @@
     },
     {
       "id": "decode#549fc51c907a/ansi_on",
-      "reason": "SELECT decode(2, array(1, 2), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(2, array(1, 2), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#549fc51c907a/ansi_off",
-      "reason": "SELECT decode(2, array(1, 2), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(2, array(1, 2), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#54a5e4b42394/ansi_on",
@@ -1834,11 +1818,11 @@
     },
     {
       "id": "decode#575e50277371/ansi_on",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#575e50277371/ansi_off",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#57c4698db3f6/ansi_on",
@@ -1890,11 +1874,11 @@
     },
     {
       "id": "decode#5aa23992c7cb/ansi_on",
-      "reason": "SELECT decode(2, 1, array(1, 2), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, array(1, 2), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#5aa23992c7cb/ansi_off",
-      "reason": "SELECT decode(2, 1, array(1, 2), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, array(1, 2), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#5b915fd83019/ansi_on",
@@ -2354,11 +2338,11 @@
     },
     {
       "id": "decode#7169a30d7b10/ansi_on",
-      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#7169a30d7b10/ansi_off",
-      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#716e422d2bf5/ansi_on",
@@ -2410,11 +2394,11 @@
     },
     {
       "id": "decode#75d59c04b0ba/ansi_on",
-      "reason": "SELECT decode(null, 6, 'Spark', NULL, array(1, 2), 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(null, 6, 'Spark', NULL, array(1, 2), 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#75d59c04b0ba/ansi_off",
-      "reason": "SELECT decode(null, 6, 'Spark', NULL, array(1, 2), 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(null, 6, 'Spark', NULL, array(1, 2), 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#772c8a60ab49/ansi_on",
@@ -2482,11 +2466,11 @@
     },
     {
       "id": "decode#7b15bb38e204/ansi_on",
-      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, array(1, 2), 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, array(1, 2), 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#7b15bb38e204/ansi_off",
-      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, array(1, 2), 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, array(1, 2), 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#7b2469f7640b/ansi_on",
@@ -2842,11 +2826,11 @@
     },
     {
       "id": "decode#8e046613975b/ansi_on",
-      "reason": "SELECT decode(6, 1, 'Southlake', 2, array(1, 2), 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', 2, array(1, 2), 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#8e046613975b/ansi_off",
-      "reason": "SELECT decode(6, 1, 'Southlake', 2, array(1, 2), 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', 2, array(1, 2), 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#8e0f971f2276/ansi_on",
@@ -3282,11 +3266,11 @@
     },
     {
       "id": "decode#a26d3b093813/ansi_on",
-      "reason": "SELECT decode(null, 6, 'Spark', array(1, 2), 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT decode(null, 6, 'Spark', array(1, 2), 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments"
     },
     {
       "id": "decode#a26d3b093813/ansi_off",
-      "reason": "SELECT decode(null, 6, 'Spark', array(1, 2), 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT decode(null, 6, 'Spark', array(1, 2), 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments"
     },
     {
       "id": "decode#a2bf0b5656c7/ansi_on",
@@ -3466,11 +3450,11 @@
     },
     {
       "id": "decode#afc7d2bef933/ansi_on",
-      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', array(1, 2), 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', array(1, 2), 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#afc7d2bef933/ansi_off",
-      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', array(1, 2), 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', array(1, 2), 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#afedaefd3247/ansi_on",
@@ -3770,11 +3754,11 @@
     },
     {
       "id": "decode#bd78443ac149/ansi_on",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', array(1, 2), 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', array(1, 2), 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#bd78443ac149/ansi_off",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', array(1, 2), 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', array(1, 2), 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#bdc91a829651/ansi_on",
@@ -3954,11 +3938,11 @@
     },
     {
       "id": "decode#c598c289e4ee/ansi_on",
-      "reason": "SELECT decode(6, array(1, 2), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(6, array(1, 2), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#c598c289e4ee/ansi_off",
-      "reason": "SELECT decode(6, array(1, 2), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(6, array(1, 2), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#c5d0ad6e7dc9/ansi_on",
@@ -4506,11 +4490,11 @@
     },
     {
       "id": "decode#dcfb79179cdd/ansi_on",
-      "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#dcfb79179cdd/ansi_off",
-      "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#dd527bc88de1/ansi_on",
@@ -4522,11 +4506,11 @@
     },
     {
       "id": "decode#dd7d562a29fc/ansi_on",
-      "reason": "SELECT decode(null, 6, array(1, 2), NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(null, 6, array(1, 2), NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#dd7d562a29fc/ansi_off",
-      "reason": "SELECT decode(null, 6, array(1, 2), NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(null, 6, array(1, 2), NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#de493ccd4bc8/ansi_on",
@@ -4842,19 +4826,19 @@
     },
     {
       "id": "decode#ee487c8acbb0/ansi_on",
-      "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', array(1, 2), 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', array(1, 2), 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments"
     },
     {
       "id": "decode#ee487c8acbb0/ansi_off",
-      "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', array(1, 2), 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', array(1, 2), 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments"
     },
     {
       "id": "decode#ee60f58ab810/ansi_on",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, array(1, 2), 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, array(1, 2), 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#ee60f58ab810/ansi_off",
-      "reason": "SELECT decode(2, 1, 'Southlake', 2, array(1, 2), 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', 2, array(1, 2), 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "decode#eea73479fe6c/ansi_on",
@@ -4914,11 +4898,11 @@
     },
     {
       "id": "decode#f14bb4f58fa1/ansi_on",
-      "reason": "SELECT decode(array(1, 2), 6, 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(array(1, 2), 6, 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#f14bb4f58fa1/ansi_off",
-      "reason": "SELECT decode(array(1, 2), 6, 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(array(1, 2), 6, 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#f1cea5ee1047/ansi_on",
@@ -5002,11 +4986,11 @@
     },
     {
       "id": "decode#f6305c250204/ansi_on",
-      "reason": "SELECT decode(2, 1, 'Southlake', array(1, 2), 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', array(1, 2), 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#f6305c250204/ansi_off",
-      "reason": "SELECT decode(2, 1, 'Southlake', array(1, 2), 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT decode(2, 1, 'Southlake', array(1, 2), 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "decode#f63db089d29b/ansi_on",
diff --git a/tests/fixtures/analysis/registry-matrix/degrees.json b/tests/fixtures/analysis/registry-matrix/degrees.json
index 8fd6d81ee..af8f5bd9f 100644
--- a/tests/fixtures/analysis/registry-matrix/degrees.json
+++ b/tests/fixtures/analysis/registry-matrix/degrees.json
@@ -8,14 +8,6 @@
       "id": "degrees#9a381aac8d04/ansi_off",
       "reason": "SELECT degrees(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "degrees#a6a490bd9aef/ansi_on",
-      "reason": "SELECT degrees(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "degrees#a6a490bd9aef/ansi_off",
-      "reason": "SELECT degrees(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "degrees#baea01745120/ansi_on",
       "reason": "SELECT degrees(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/elt.json b/tests/fixtures/analysis/registry-matrix/elt.json
index 235233edf..503312f55 100644
--- a/tests/fixtures/analysis/registry-matrix/elt.json
+++ b/tests/fixtures/analysis/registry-matrix/elt.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "elt#088805bde507/ansi_on",
-      "reason": "SELECT elt(1, array(1, 2), 'java') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "elt#088805bde507/ansi_off",
-      "reason": "SELECT elt(1, array(1, 2), 'java') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "elt#48f1636d3e8d/ansi_on",
       "reason": "SELECT elt(1, 'scala', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -24,14 +16,6 @@
       "id": "elt#55f6a49adeb2/ansi_off",
       "reason": "SELECT elt(1, INTERVAL '1-2' YEAR TO MONTH, 'java') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "elt#66be35451d54/ansi_on",
-      "reason": "SELECT elt(array(1, 2), 'scala', 'java') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "elt#66be35451d54/ansi_off",
-      "reason": "SELECT elt(array(1, 2), 'scala', 'java') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "elt#66ed2b35d9f6/ansi_on",
       "reason": "SELECT elt(INTERVAL '1 02:03:04' DAY TO SECOND, 'scala', 'java') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -48,14 +32,6 @@
       "id": "elt#74374fa93e05/ansi_off",
       "reason": "SELECT elt(INTERVAL '1-2' YEAR TO MONTH, 'scala', 'java') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "elt#9e38830aad17/ansi_on",
-      "reason": "SELECT elt(1, 'scala', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "elt#9e38830aad17/ansi_off",
-      "reason": "SELECT elt(1, 'scala', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "elt#a5032d6ca00a/ansi_on",
       "reason": "SELECT elt(1, INTERVAL '1 02:03:04' DAY TO SECOND, 'java') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/encode.json b/tests/fixtures/analysis/registry-matrix/encode.json
index e24a615d1..e8c92dcf6 100644
--- a/tests/fixtures/analysis/registry-matrix/encode.json
+++ b/tests/fixtures/analysis/registry-matrix/encode.json
@@ -24,14 +24,6 @@
       "id": "encode#74c48c4e948c/ansi_off",
       "reason": "SELECT encode(INTERVAL '1 02:03:04' DAY TO SECOND, 'utf-8') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "encode#9dd4a26f0636/ansi_on",
-      "reason": "SELECT encode(array(1, 2), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "encode#9dd4a26f0636/ansi_off",
-      "reason": "SELECT encode(array(1, 2), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "encode#cbde63238f70/ansi_on",
       "reason": "SELECT encode('abc', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -40,14 +32,6 @@
       "id": "encode#cbde63238f70/ansi_off",
       "reason": "SELECT encode('abc', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "encode#d880a267ff0e/ansi_on",
-      "reason": "SELECT encode('abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "encode#d880a267ff0e/ansi_off",
-      "reason": "SELECT encode('abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "encode#ed99015663e0/ansi_on",
       "reason": "SELECT encode('abc', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/endswith.json b/tests/fixtures/analysis/registry-matrix/endswith.json
index 187daceb6..8e810f8f4 100644
--- a/tests/fixtures/analysis/registry-matrix/endswith.json
+++ b/tests/fixtures/analysis/registry-matrix/endswith.json
@@ -32,14 +32,6 @@
       "id": "endswith#7fc3b35cb0fa/ansi_off",
       "reason": "SELECT endswith(INTERVAL '1-2' YEAR TO MONTH, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "endswith#9d22842205a0/ansi_on",
-      "reason": "SELECT endswith(array(1, 2), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "endswith#9d22842205a0/ansi_off",
-      "reason": "SELECT endswith(array(1, 2), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "endswith#b18796f06dfa/ansi_on",
       "reason": "SELECT endswith('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -48,14 +40,6 @@
       "id": "endswith#b18796f06dfa/ansi_off",
       "reason": "SELECT endswith('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "endswith#db6f4211cf83/ansi_on",
-      "reason": "SELECT endswith('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "endswith#db6f4211cf83/ansi_off",
-      "reason": "SELECT endswith('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "endswith#dd88f7cef81d/ansi_on",
       "reason": "SELECT endswith(INTERVAL '1 02:03:04' DAY TO SECOND, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/equal_null.json b/tests/fixtures/analysis/registry-matrix/equal_null.json
index 66c9a06b1..9d6d42319 100644
--- a/tests/fixtures/analysis/registry-matrix/equal_null.json
+++ b/tests/fixtures/analysis/registry-matrix/equal_null.json
@@ -4,14 +4,6 @@
       "id": "equal_null#0355330fa7f3/ansi_off",
       "reason": "SELECT equal_null(3, true) | DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "equal_null#151a5c0cbdc9/ansi_on",
-      "reason": "SELECT equal_null(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "equal_null#151a5c0cbdc9/ansi_off",
-      "reason": "SELECT equal_null(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "equal_null#2992d8a79db7/ansi_on",
       "reason": "SELECT equal_null(3, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -100,14 +92,6 @@
       "id": "equal_null#dbc27bba4cc8/ansi_off",
       "reason": "SELECT equal_null(3, 'abc') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "equal_null#dd257456f4cb/ansi_on",
-      "reason": "SELECT equal_null(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "equal_null#dd257456f4cb/ansi_off",
-      "reason": "SELECT equal_null(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "equal_null#e2ccee8023d2/ansi_off",
       "reason": "SELECT equal_null(3, '1') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
diff --git a/tests/fixtures/analysis/registry-matrix/exists.json b/tests/fixtures/analysis/registry-matrix/exists.json
new file mode 100644
index 000000000..3dbe91e37
--- /dev/null
+++ b/tests/fixtures/analysis/registry-matrix/exists.json
@@ -0,0 +1,30 @@
+{
+  "entries": [
+    {
+      "id": "exists#6a6847e8ef3b/ansi_on",
+      "reason": "SELECT exists(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "exists#6a6847e8ef3b/ansi_off",
+      "reason": "SELECT exists(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "exists#6e826ed77c7c/ansi_on",
+      "reason": "SELECT exists(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "exists#6e826ed77c7c/ansi_off",
+      "reason": "SELECT exists(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "exists#da2bc52421fa/ansi_on",
+      "reason": "SELECT exists(map('a', 1), x -> x % 2 == 0) | parse: PARSE_SYNTAX_ERROR where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "exists#da2bc52421fa/ansi_off",
+      "reason": "SELECT exists(map('a', 1), x -> x % 2 == 0) | parse: PARSE_SYNTAX_ERROR where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    }
+  ],
+  "format_version": 1,
+  "function": "exists"
+}
diff --git a/tests/fixtures/analysis/registry-matrix/exp.json b/tests/fixtures/analysis/registry-matrix/exp.json
index b1bbbc55b..497b14027 100644
--- a/tests/fixtures/analysis/registry-matrix/exp.json
+++ b/tests/fixtures/analysis/registry-matrix/exp.json
@@ -16,14 +16,6 @@
       "id": "exp#c0495deda736/ansi_off",
       "reason": "SELECT exp(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "exp#eec810ac174b/ansi_on",
-      "reason": "SELECT exp(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "exp#eec810ac174b/ansi_off",
-      "reason": "SELECT exp(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "exp#f67051cd986a/ansi_on",
       "reason": "SELECT exp(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/expm1.json b/tests/fixtures/analysis/registry-matrix/expm1.json
index 1a6414348..43359a945 100644
--- a/tests/fixtures/analysis/registry-matrix/expm1.json
+++ b/tests/fixtures/analysis/registry-matrix/expm1.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "expm1#235cf212eb44/ansi_on",
-      "reason": "SELECT expm1(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "expm1#235cf212eb44/ansi_off",
-      "reason": "SELECT expm1(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "expm1#34c7be4db61b/ansi_on",
       "reason": "SELECT expm1(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/filter.json b/tests/fixtures/analysis/registry-matrix/filter.json
new file mode 100644
index 000000000..79c47119e
--- /dev/null
+++ b/tests/fixtures/analysis/registry-matrix/filter.json
@@ -0,0 +1,38 @@
+{
+  "entries": [
+    {
+      "id": "filter#5cb73ec32bff/ansi_on",
+      "reason": "SELECT filter(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "filter#5cb73ec32bff/ansi_off",
+      "reason": "SELECT filter(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "filter#87053e478033/ansi_on",
+      "reason": "SELECT filter(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "filter#87053e478033/ansi_off",
+      "reason": "SELECT filter(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "filter#b772a52335ae/ansi_on",
+      "reason": "SELECT filter(map('a', 1), x -> x % 2 == 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "filter#b772a52335ae/ansi_off",
+      "reason": "SELECT filter(map('a', 1), x -> x % 2 == 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "filter#cc869a817020/ansi_on",
+      "reason": "SELECT filter(array(0, 2, 3), (x, i) -> x > i) | INVALID_LAMBDA_FUNCTION_CALL.NUM_ARGS_MISMATCH"
+    },
+    {
+      "id": "filter#cc869a817020/ansi_off",
+      "reason": "SELECT filter(array(0, 2, 3), (x, i) -> x > i) | INVALID_LAMBDA_FUNCTION_CALL.NUM_ARGS_MISMATCH"
+    }
+  ],
+  "format_version": 1,
+  "function": "filter"
+}
diff --git a/tests/fixtures/analysis/registry-matrix/find_in_set.json b/tests/fixtures/analysis/registry-matrix/find_in_set.json
index 92ebe591f..332f1c65f 100644
--- a/tests/fixtures/analysis/registry-matrix/find_in_set.json
+++ b/tests/fixtures/analysis/registry-matrix/find_in_set.json
@@ -24,14 +24,6 @@
       "id": "find_in_set#13c7df199694/ansi_off",
       "reason": "SELECT find_in_set('ab',INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "find_in_set#202d1b26addc/ansi_on",
-      "reason": "SELECT find_in_set(array(1, 2),'abc,b,ab,c,def') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "find_in_set#202d1b26addc/ansi_off",
-      "reason": "SELECT find_in_set(array(1, 2),'abc,b,ab,c,def') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "find_in_set#6fa5b2df63d8/ansi_on",
       "reason": "SELECT find_in_set('ab',map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -48,14 +40,6 @@
       "id": "find_in_set#73fb1df4d3b1/ansi_off",
       "reason": "SELECT find_in_set(INTERVAL '1 02:03:04' DAY TO SECOND,'abc,b,ab,c,def') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "find_in_set#85b259a6c9b0/ansi_on",
-      "reason": "SELECT find_in_set('ab',array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "find_in_set#85b259a6c9b0/ansi_off",
-      "reason": "SELECT find_in_set('ab',array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "find_in_set#bef48bdf9089/ansi_on",
       "reason": "SELECT find_in_set('ab',INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/first.json b/tests/fixtures/analysis/registry-matrix/first.json
index 2a069c194..9f83e8128 100644
--- a/tests/fixtures/analysis/registry-matrix/first.json
+++ b/tests/fixtures/analysis/registry-matrix/first.json
@@ -23,14 +23,6 @@
     {
       "id": "first#58b60a8472c9/ansi_off",
       "reason": "SELECT first(col, INTERVAL '1 02:03:04' DAY TO SECOND) FROM VALUES (NULL), (5), (20) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210"
-    },
-    {
-      "id": "first#7142e82e71a1/ansi_on",
-      "reason": "SELECT first(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210"
-    },
-    {
-      "id": "first#7142e82e71a1/ansi_off",
-      "reason": "SELECT first(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/first_value.json b/tests/fixtures/analysis/registry-matrix/first_value.json
index f0fb039de..1219c968b 100644
--- a/tests/fixtures/analysis/registry-matrix/first_value.json
+++ b/tests/fixtures/analysis/registry-matrix/first_value.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "first_value#0e35783b59e8/ansi_on",
-      "reason": "SELECT first_value(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210"
-    },
-    {
-      "id": "first_value#0e35783b59e8/ansi_off",
-      "reason": "SELECT first_value(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210"
-    },
     {
       "id": "first_value#5f9c5c85c0ca/ansi_on",
       "reason": "SELECT first_value(col, INTERVAL '1 02:03:04' DAY TO SECOND) FROM VALUES (NULL), (5), (20) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210"
diff --git a/tests/fixtures/analysis/registry-matrix/floor.json b/tests/fixtures/analysis/registry-matrix/floor.json
index d623bad1c..6332f3d16 100644
--- a/tests/fixtures/analysis/registry-matrix/floor.json
+++ b/tests/fixtures/analysis/registry-matrix/floor.json
@@ -48,14 +48,6 @@
       "id": "floor#716ba7127f26/ansi_off",
       "reason": "SELECT floor(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "floor#730d8fe10a5a/ansi_on",
-      "reason": "SELECT floor(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "floor#730d8fe10a5a/ansi_off",
-      "reason": "SELECT floor(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT"
-    },
     {
       "id": "floor#986519e90987/ansi_on",
       "reason": "SELECT floor(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -72,22 +64,6 @@
       "id": "floor#a8fb09ca0432/ansi_off",
       "reason": "SELECT floor(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "floor#c55c5c7689d7/ansi_on",
-      "reason": "SELECT floor(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "floor#c55c5c7689d7/ansi_off",
-      "reason": "SELECT floor(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "floor#eafebbc04618/ansi_on",
-      "reason": "SELECT floor(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "floor#eafebbc04618/ansi_off",
-      "reason": "SELECT floor(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "floor#f7b36fd3e154/ansi_on",
       "reason": "SELECT floor(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/forall.json b/tests/fixtures/analysis/registry-matrix/forall.json
new file mode 100644
index 000000000..26b783b40
--- /dev/null
+++ b/tests/fixtures/analysis/registry-matrix/forall.json
@@ -0,0 +1,30 @@
+{
+  "entries": [
+    {
+      "id": "forall#0c7952ae1a01/ansi_on",
+      "reason": "SELECT forall(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "forall#0c7952ae1a01/ansi_off",
+      "reason": "SELECT forall(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "forall#7781d8d40b2b/ansi_on",
+      "reason": "SELECT forall(map('a', 1), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "forall#7781d8d40b2b/ansi_off",
+      "reason": "SELECT forall(map('a', 1), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "forall#a88594001a66/ansi_on",
+      "reason": "SELECT forall(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "forall#a88594001a66/ansi_off",
+      "reason": "SELECT forall(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    }
+  ],
+  "format_version": 1,
+  "function": "forall"
+}
diff --git a/tests/fixtures/analysis/registry-matrix/format_number.json b/tests/fixtures/analysis/registry-matrix/format_number.json
index c896e57f3..af01653b9 100644
--- a/tests/fixtures/analysis/registry-matrix/format_number.json
+++ b/tests/fixtures/analysis/registry-matrix/format_number.json
@@ -24,14 +24,6 @@
       "id": "format_number#76613646826f/ansi_off",
       "reason": "SELECT format_number(12332.123456, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "format_number#a01c09659bab/ansi_on",
-      "reason": "SELECT format_number(12332.123456, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "format_number#a01c09659bab/ansi_off",
-      "reason": "SELECT format_number(12332.123456, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "format_number#ba6583b472bc/ansi_on",
       "reason": "SELECT format_number(12332.123456, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,14 +32,6 @@
       "id": "format_number#ba6583b472bc/ansi_off",
       "reason": "SELECT format_number(12332.123456, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "format_number#de8e4198e9f4/ansi_on",
-      "reason": "SELECT format_number(array(1, 2), 4) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "format_number#de8e4198e9f4/ansi_off",
-      "reason": "SELECT format_number(array(1, 2), 4) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "format_number#f2eb3f7a47db/ansi_on",
       "reason": "SELECT format_number(INTERVAL '1 02:03:04' DAY TO SECOND, 4) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json b/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json
index 9711f2250..c7adbc4d4 100644
--- a/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json
+++ b/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json
@@ -32,14 +32,6 @@
       "id": "from_utc_timestamp#70953829339b/ansi_off",
       "reason": "SELECT from_utc_timestamp('2016-08-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "from_utc_timestamp#7a2f639bdf28/ansi_on",
-      "reason": "SELECT from_utc_timestamp(array(1, 2), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "from_utc_timestamp#7a2f639bdf28/ansi_off",
-      "reason": "SELECT from_utc_timestamp(array(1, 2), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "from_utc_timestamp#83b5c806c510/ansi_on",
       "reason": "SELECT from_utc_timestamp('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -48,14 +40,6 @@
       "id": "from_utc_timestamp#83b5c806c510/ansi_off",
       "reason": "SELECT from_utc_timestamp('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "from_utc_timestamp#94ac3581dfd4/ansi_on",
-      "reason": "SELECT from_utc_timestamp('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "from_utc_timestamp#94ac3581dfd4/ansi_off",
-      "reason": "SELECT from_utc_timestamp('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "from_utc_timestamp#c986a44036f4/ansi_on",
       "reason": "SELECT from_utc_timestamp('2016-08-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/getbit.json b/tests/fixtures/analysis/registry-matrix/getbit.json
index 926f30a9f..8df20ef0d 100644
--- a/tests/fixtures/analysis/registry-matrix/getbit.json
+++ b/tests/fixtures/analysis/registry-matrix/getbit.json
@@ -16,14 +16,6 @@
       "id": "getbit#62e5bcef8380/ansi_off",
       "reason": "SELECT getbit(11, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "getbit#699ba6576802/ansi_on",
-      "reason": "SELECT getbit(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "getbit#699ba6576802/ansi_off",
-      "reason": "SELECT getbit(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "getbit#7579ff069735/ansi_on",
       "reason": "SELECT getbit(INTERVAL '1 02:03:04' DAY TO SECOND, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,14 +32,6 @@
       "id": "getbit#915c2a9d1452/ansi_off",
       "reason": "SELECT getbit(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "getbit#9419dda3fafc/ansi_on",
-      "reason": "SELECT getbit(11, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "getbit#9419dda3fafc/ansi_off",
-      "reason": "SELECT getbit(11, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "getbit#9a65369e9227/ansi_on",
       "reason": "SELECT getbit(11, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/greatest.json b/tests/fixtures/analysis/registry-matrix/greatest.json
index e2a1f2440..03c69d430 100644
--- a/tests/fixtures/analysis/registry-matrix/greatest.json
+++ b/tests/fixtures/analysis/registry-matrix/greatest.json
@@ -16,14 +16,6 @@
       "id": "greatest#096852702824/ansi_off",
       "reason": "SELECT greatest(INTERVAL '1 02:03:04' DAY TO SECOND, 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "greatest#13c6afe65002/ansi_on",
-      "reason": "SELECT greatest(array(1, 2), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#13c6afe65002/ansi_off",
-      "reason": "SELECT greatest(array(1, 2), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "greatest#153b990a709e/ansi_on",
       "reason": "SELECT greatest(INTERVAL '1-2' YEAR TO MONTH, 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -40,14 +32,6 @@
       "id": "greatest#27d19c21be34/ansi_off",
       "reason": "SELECT greatest(10, 9, 2, 4, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "greatest#3ae8320b93cc/ansi_on",
-      "reason": "SELECT greatest(10, array(1, 2), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#3ae8320b93cc/ansi_off",
-      "reason": "SELECT greatest(10, array(1, 2), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "greatest#3b87446f2696/ansi_on",
       "reason": "SELECT greatest(10, 9, 2, INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -72,14 +56,6 @@
       "id": "greatest#69f9244398a6/ansi_off",
       "reason": "SELECT greatest(10, 9, 2, 4, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "greatest#80f86bb7e057/ansi_on",
-      "reason": "SELECT greatest(10, 9, 2, 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#80f86bb7e057/ansi_off",
-      "reason": "SELECT greatest(10, 9, 2, 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "greatest#824668970bd6/ansi_on",
       "reason": "SELECT greatest(map('a', 1), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -88,14 +64,6 @@
       "id": "greatest#824668970bd6/ansi_off",
       "reason": "SELECT greatest(map('a', 1), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "greatest#91ff7769043f/ansi_on",
-      "reason": "SELECT greatest(10, 9, 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#91ff7769043f/ansi_off",
-      "reason": "SELECT greatest(10, 9, 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "greatest#98f8bb73a148/ansi_on",
       "reason": "SELECT greatest(10, INTERVAL '1 02:03:04' DAY TO SECOND, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -128,14 +96,6 @@
       "id": "greatest#b2adb244d3ee/ansi_off",
       "reason": "SELECT greatest(10, 9, 2, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "greatest#b51e4d0651cf/ansi_on",
-      "reason": "SELECT greatest(10, 9, array(1, 2), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#b51e4d0651cf/ansi_off",
-      "reason": "SELECT greatest(10, 9, array(1, 2), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "greatest#c02bd5367c35/ansi_on",
       "reason": "SELECT greatest(10, 9, map('a', 1), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
diff --git a/tests/fixtures/analysis/registry-matrix/hash.json b/tests/fixtures/analysis/registry-matrix/hash.json
index 0888b48f8..37b3a1127 100644
--- a/tests/fixtures/analysis/registry-matrix/hash.json
+++ b/tests/fixtures/analysis/registry-matrix/hash.json
@@ -1,69 +1,5 @@
 {
   "entries": [
-    {
-      "id": "hash#050efa42b0aa/ansi_on",
-      "reason": "SELECT hash(1, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#050efa42b0aa/ansi_off",
-      "reason": "SELECT hash(1, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#06b7e5d007f1/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), CAST(1 AS TINYINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#06b7e5d007f1/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), CAST(1 AS TINYINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#07ecd1ec737e/ansi_on",
-      "reason": "SELECT hash('Ä€日本語😀é', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#07ecd1ec737e/ansi_off",
-      "reason": "SELECT hash('Ä€日本語😀é', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#10a009d846e4/ansi_on",
-      "reason": "SELECT hash(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#10a009d846e4/ansi_off",
-      "reason": "SELECT hash(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#11dc78602219/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), CAST(1 AS SMALLINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#11dc78602219/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), CAST(1 AS SMALLINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#16de041f73d5/ansi_on",
-      "reason": "SELECT hash('Spark', CAST(array() AS array<int>), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#16de041f73d5/ansi_off",
-      "reason": "SELECT hash('Spark', CAST(array() AS array<int>), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#17ae377c1c3e/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), 'abc') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#17ae377c1c3e/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), 'abc') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#183f10259830/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), 1L) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#183f10259830/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), 1L) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "hash#1d95ab5f2f7f/ansi_on",
       "reason": "SELECT hash(INTERVAL '1 02:03:04' DAY TO SECOND, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -72,94 +8,6 @@
       "id": "hash#1d95ab5f2f7f/ansi_off",
       "reason": "SELECT hash(INTERVAL '1 02:03:04' DAY TO SECOND, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "hash#20ac6b855c3f/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#20ac6b855c3f/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#239f9a29c6da/ansi_on",
-      "reason": "SELECT hash(NULL, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#239f9a29c6da/ansi_off",
-      "reason": "SELECT hash(NULL, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#243662e44338/ansi_on",
-      "reason": "SELECT hash(DATE'2024-02-29', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#243662e44338/ansi_off",
-      "reason": "SELECT hash(DATE'2024-02-29', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#272caba7a158/ansi_on",
-      "reason": "SELECT hash(named_struct('a', 1, 'b', 'x'), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#272caba7a158/ansi_off",
-      "reason": "SELECT hash(named_struct('a', 1, 'b', 'x'), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#31388d31f097/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), X'01') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#31388d31f097/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), X'01') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#36486ceb689e/ansi_on",
-      "reason": "SELECT hash('abc', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#36486ceb689e/ansi_off",
-      "reason": "SELECT hash('abc', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#40b05b7dd3b8/ansi_on",
-      "reason": "SELECT hash(CAST(1.5 AS FLOAT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#40b05b7dd3b8/ansi_off",
-      "reason": "SELECT hash(CAST(1.5 AS FLOAT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#4662df6e4cfe/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#4662df6e4cfe/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#4a599039809c/ansi_on",
-      "reason": "SELECT hash(CAST(NULL AS string), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#4a599039809c/ansi_off",
-      "reason": "SELECT hash(CAST(NULL AS string), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#4bb2495feeff/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), CAST(-2147483648 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#4bb2495feeff/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), CAST(-2147483648 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#4d1d1a99deac/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#4d1d1a99deac/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "hash#51a176d3611e/ansi_on",
       "reason": "SELECT hash('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
@@ -168,54 +16,6 @@
       "id": "hash#51a176d3611e/ansi_off",
       "reason": "SELECT hash('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
     },
-    {
-      "id": "hash#5556de897838/ansi_on",
-      "reason": "SELECT hash('1', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#5556de897838/ansi_off",
-      "reason": "SELECT hash('1', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#56ac03b0a2dd/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), DATE'2024-02-29') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#56ac03b0a2dd/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), DATE'2024-02-29') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#57961fe78970/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#57961fe78970/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#58278334416c/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), 1.5D) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#58278334416c/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), 1.5D) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#5a4364ed7c74/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS FLOAT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#5a4364ed7c74/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS FLOAT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#5a92f4b086c0/ansi_on",
-      "reason": "SELECT hash(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#5a92f4b086c0/ansi_off",
-      "reason": "SELECT hash(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "hash#68ccd0f7afcd/ansi_on",
       "reason": "SELECT hash(map('a', 1), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
@@ -232,14 +32,6 @@
       "id": "hash#7d1796847464/ansi_off",
       "reason": "SELECT hash('Spark', array(123), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "hash#80833cec99fa/ansi_on",
-      "reason": "SELECT hash(X'01', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#80833cec99fa/ansi_off",
-      "reason": "SELECT hash(X'01', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "hash#838d1e1f3358/ansi_on",
       "reason": "SELECT hash('Spark', INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -248,102 +40,6 @@
       "id": "hash#838d1e1f3358/ansi_off",
       "reason": "SELECT hash('Spark', INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "hash#845996a4629b/ansi_on",
-      "reason": "SELECT hash('Spark', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#845996a4629b/ansi_off",
-      "reason": "SELECT hash('Spark', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#8f28ae489069/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), CAST(NULL AS int)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#8f28ae489069/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), CAST(NULL AS int)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#9064665edbfa/ansi_on",
-      "reason": "SELECT hash(' \\t a\\u3000\\n ', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#9064665edbfa/ansi_off",
-      "reason": "SELECT hash(' \\t a\\u3000\\n ', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#917eb41cb472/ansi_on",
-      "reason": "SELECT hash(CAST(1 AS SMALLINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#917eb41cb472/ansi_off",
-      "reason": "SELECT hash(CAST(1 AS SMALLINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#92152fb6e67b/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#92152fb6e67b/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#96987ccd7021/ansi_on",
-      "reason": "SELECT hash(array(1, 2), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#96987ccd7021/ansi_off",
-      "reason": "SELECT hash(array(1, 2), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#98df9e5ecfbd/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#98df9e5ecfbd/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#9b5eaf237af0/ansi_on",
-      "reason": "SELECT hash(1L, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#9b5eaf237af0/ansi_off",
-      "reason": "SELECT hash(1L, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#a188de4365ba/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS DECIMAL(10,2))) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#a188de4365ba/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS DECIMAL(10,2))) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#a2161c8521d0/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), CAST(2147483647 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#a2161c8521d0/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), CAST(2147483647 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#a3ecac8e4a34/ansi_on",
-      "reason": "SELECT hash(CAST(1 AS TINYINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#a3ecac8e4a34/ansi_off",
-      "reason": "SELECT hash(CAST(1 AS TINYINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#a93fbeb6bcb3/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#a93fbeb6bcb3/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "hash#ab6c7c5a6f40/ansi_on",
       "reason": "SELECT hash('Spark', INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -360,46 +56,6 @@
       "id": "hash#adbe9020216d/ansi_off",
       "reason": "SELECT hash('Spark', array(123), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "hash#b0f0a6b58919/ansi_on",
-      "reason": "SELECT hash('', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#b0f0a6b58919/ansi_off",
-      "reason": "SELECT hash('', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#b5e5daa7ad5f/ansi_on",
-      "reason": "SELECT hash(CAST(1.5 AS DECIMAL(38,18)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#b5e5daa7ad5f/ansi_off",
-      "reason": "SELECT hash(CAST(1.5 AS DECIMAL(38,18)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#bca5749aac50/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), true) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#bca5749aac50/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), true) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#be26072f51ea/ansi_on",
-      "reason": "SELECT hash('Spark', CAST(array(NULL) AS array<int>), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#be26072f51ea/ansi_off",
-      "reason": "SELECT hash('Spark', CAST(array(NULL) AS array<int>), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#cca3887f32a9/ansi_on",
-      "reason": "SELECT hash(CAST(1.5 AS DECIMAL(10,2)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#cca3887f32a9/ansi_off",
-      "reason": "SELECT hash(CAST(1.5 AS DECIMAL(10,2)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "hash#ce8dfe4ae46a/ansi_on",
       "reason": "SELECT hash(INTERVAL '1-2' YEAR TO MONTH, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -408,53 +64,13 @@
       "id": "hash#ce8dfe4ae46a/ansi_off",
       "reason": "SELECT hash(INTERVAL '1-2' YEAR TO MONTH, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "hash#cf54e7b823e9/ansi_on",
-      "reason": "SELECT hash(1.5D, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#cf54e7b823e9/ansi_off",
-      "reason": "SELECT hash(1.5D, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#d8fe25feb621/ansi_on",
-      "reason": "SELECT hash(CAST(X'C328FF' AS STRING), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#d8fe25feb621/ansi_off",
-      "reason": "SELECT hash(CAST(X'C328FF' AS STRING), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#dca435a0527c/ansi_on",
-      "reason": "SELECT hash(true, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#dca435a0527c/ansi_off",
-      "reason": "SELECT hash(true, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#e450fde5e857/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#e450fde5e857/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "hash#f0c7f0566e00/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
+      "reason": "SELECT hash('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
     },
     {
       "id": "hash#f0c7f0566e00/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
-    },
-    {
-      "id": "hash#f8a07689fe61/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS DECIMAL(38,18))) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "hash#f8a07689fe61/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS DECIMAL(38,18))) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT hash('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/hex.json b/tests/fixtures/analysis/registry-matrix/hex.json
index ec6982153..4e228c1eb 100644
--- a/tests/fixtures/analysis/registry-matrix/hex.json
+++ b/tests/fixtures/analysis/registry-matrix/hex.json
@@ -23,14 +23,6 @@
     {
       "id": "hex#990c738c9ac5/ansi_off",
       "reason": "SELECT hex(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "hex#a8eccfab7f94/ansi_on",
-      "reason": "SELECT hex(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "hex#a8eccfab7f94/ansi_off",
-      "reason": "SELECT hex(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/hour.json b/tests/fixtures/analysis/registry-matrix/hour.json
index 61953ce00..8b0b33083 100644
--- a/tests/fixtures/analysis/registry-matrix/hour.json
+++ b/tests/fixtures/analysis/registry-matrix/hour.json
@@ -8,14 +8,6 @@
       "id": "hour#07c6294f169d/ansi_off",
       "reason": "SELECT hour(CAST(NULL AS time(6))) | parse: KRISHIV_UNSUPPORTED_FEATURE: the time data type (\"TIME\") where Spark has UNSUPPORTED_TIME_TYPE"
     },
-    {
-      "id": "hour#207d9afe7813/ansi_on",
-      "reason": "SELECT hour(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "hour#207d9afe7813/ansi_off",
-      "reason": "SELECT hour(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "hour#764b1ec0e160/ansi_on",
       "reason": "SELECT hour(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/hypot.json b/tests/fixtures/analysis/registry-matrix/hypot.json
index 20b142640..fd6d0b900 100644
--- a/tests/fixtures/analysis/registry-matrix/hypot.json
+++ b/tests/fixtures/analysis/registry-matrix/hypot.json
@@ -40,14 +40,6 @@
       "id": "hypot#5c6c6b1a9581/ansi_off",
       "reason": "SELECT hypot(map('a', 1), 4) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "hypot#5ef785b91579/ansi_on",
-      "reason": "SELECT hypot(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "hypot#5ef785b91579/ansi_off",
-      "reason": "SELECT hypot(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "hypot#b0f1ca89094f/ansi_on",
       "reason": "SELECT hypot(3, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -55,14 +47,6 @@
     {
       "id": "hypot#b0f1ca89094f/ansi_off",
       "reason": "SELECT hypot(3, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "hypot#f42712dc9ca1/ansi_on",
-      "reason": "SELECT hypot(array(1, 2), 4) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "hypot#f42712dc9ca1/ansi_off",
-      "reason": "SELECT hypot(array(1, 2), 4) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/if.json b/tests/fixtures/analysis/registry-matrix/if.json
index 06270c003..b2620f1a2 100644
--- a/tests/fixtures/analysis/registry-matrix/if.json
+++ b/tests/fixtures/analysis/registry-matrix/if.json
@@ -48,14 +48,6 @@
       "id": "if#64a43efb90e0/ansi_off",
       "reason": "SELECT if(INTERVAL '1 02:03:04' DAY TO SECOND, 'a', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "if#7ffb9c5e13de/ansi_on",
-      "reason": "SELECT if(array(1, 2), 'a', 'b') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "if#7ffb9c5e13de/ansi_off",
-      "reason": "SELECT if(array(1, 2), 'a', 'b') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "if#9d1d0cac3e7d/ansi_on",
       "reason": "SELECT if(1 < 2, INTERVAL '1-2' YEAR TO MONTH, 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -64,14 +56,6 @@
       "id": "if#9d1d0cac3e7d/ansi_off",
       "reason": "SELECT if(1 < 2, INTERVAL '1-2' YEAR TO MONTH, 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "if#b47b88b41f36/ansi_on",
-      "reason": "SELECT if(1 < 2, 'a', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "if#b47b88b41f36/ansi_off",
-      "reason": "SELECT if(1 < 2, 'a', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "if#b6e3ea7b11fd/ansi_on",
       "reason": "SELECT if(1 < 2, INTERVAL '1 02:03:04' DAY TO SECOND, 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -80,14 +64,6 @@
       "id": "if#b6e3ea7b11fd/ansi_off",
       "reason": "SELECT if(1 < 2, INTERVAL '1 02:03:04' DAY TO SECOND, 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "if#da00eb044050/ansi_on",
-      "reason": "SELECT if(1 < 2, array(1, 2), 'b') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "if#da00eb044050/ansi_off",
-      "reason": "SELECT if(1 < 2, array(1, 2), 'b') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "if#ec0d1d6bf87a/ansi_on",
       "reason": "SELECT if(map('a', 1), 'a', 'b') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/ifnull.json b/tests/fixtures/analysis/registry-matrix/ifnull.json
index 966327556..58d148c20 100644
--- a/tests/fixtures/analysis/registry-matrix/ifnull.json
+++ b/tests/fixtures/analysis/registry-matrix/ifnull.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "ifnull#01f264e6f2a4/ansi_on",
-      "reason": "SELECT ifnull(CAST(1.5 AS DECIMAL(10,2)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#01f264e6f2a4/ansi_off",
-      "reason": "SELECT ifnull(CAST(1.5 AS DECIMAL(10,2)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "ifnull#1901fc2f1759/ansi_on",
       "reason": "SELECT ifnull(INTERVAL '1-2' YEAR TO MONTH, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -16,30 +8,6 @@
       "id": "ifnull#1901fc2f1759/ansi_off",
       "reason": "SELECT ifnull(INTERVAL '1-2' YEAR TO MONTH, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "ifnull#1bf265d2ee73/ansi_on",
-      "reason": "SELECT ifnull(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#1bf265d2ee73/ansi_off",
-      "reason": "SELECT ifnull(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#1d03a62f2a6d/ansi_on",
-      "reason": "SELECT ifnull(true, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#1d03a62f2a6d/ansi_off",
-      "reason": "SELECT ifnull(true, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#24f22a74561c/ansi_on",
-      "reason": "SELECT ifnull(named_struct('a', 1, 'b', 'x'), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#24f22a74561c/ansi_off",
-      "reason": "SELECT ifnull(named_struct('a', 1, 'b', 'x'), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "ifnull#3fead29b1417/ansi_on",
       "reason": "SELECT ifnull(INTERVAL '1 02:03:04' DAY TO SECOND, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -56,126 +24,6 @@
       "id": "ifnull#5c3f20483580/ansi_off",
       "reason": "SELECT ifnull(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "ifnull#679800a7c1ba/ansi_on",
-      "reason": "SELECT ifnull('abc', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#679800a7c1ba/ansi_off",
-      "reason": "SELECT ifnull('abc', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#6dc84bc76ae3/ansi_on",
-      "reason": "SELECT ifnull(1.5D, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#6dc84bc76ae3/ansi_off",
-      "reason": "SELECT ifnull(1.5D, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#720f10b049a9/ansi_on",
-      "reason": "SELECT ifnull(CAST(1 AS TINYINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#720f10b049a9/ansi_off",
-      "reason": "SELECT ifnull(CAST(1 AS TINYINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#7328caa97776/ansi_on",
-      "reason": "SELECT ifnull(DATE'2024-02-29', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#7328caa97776/ansi_off",
-      "reason": "SELECT ifnull(DATE'2024-02-29', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#733b0fdc47e4/ansi_on",
-      "reason": "SELECT ifnull('1', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#733b0fdc47e4/ansi_off",
-      "reason": "SELECT ifnull('1', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#780c7d54a3ff/ansi_on",
-      "reason": "SELECT ifnull(1L, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#780c7d54a3ff/ansi_off",
-      "reason": "SELECT ifnull(1L, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#828551fc1860/ansi_on",
-      "reason": "SELECT ifnull(X'01', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#828551fc1860/ansi_off",
-      "reason": "SELECT ifnull(X'01', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#86e8390fb86e/ansi_on",
-      "reason": "SELECT ifnull(NULL, CAST(array() AS array<string>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "ifnull#86e8390fb86e/ansi_off",
-      "reason": "SELECT ifnull(NULL, CAST(array() AS array<string>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "ifnull#968ad8ccd489/ansi_on",
-      "reason": "SELECT ifnull(NULL, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "ifnull#968ad8ccd489/ansi_off",
-      "reason": "SELECT ifnull(NULL, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "ifnull#969ba6758881/ansi_on",
-      "reason": "SELECT ifnull(NULL, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "ifnull#969ba6758881/ansi_off",
-      "reason": "SELECT ifnull(NULL, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "ifnull#a00353742167/ansi_on",
-      "reason": "SELECT ifnull(CAST(1 AS SMALLINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#a00353742167/ansi_off",
-      "reason": "SELECT ifnull(CAST(1 AS SMALLINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#b21b1a45795f/ansi_on",
-      "reason": "SELECT ifnull(CAST(1.5 AS FLOAT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#b21b1a45795f/ansi_off",
-      "reason": "SELECT ifnull(CAST(1.5 AS FLOAT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#b2af6cfe400b/ansi_on",
-      "reason": "SELECT ifnull(NULL, CAST(array(NULL) AS array<string>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "ifnull#b2af6cfe400b/ansi_off",
-      "reason": "SELECT ifnull(NULL, CAST(array(NULL) AS array<string>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "ifnull#bfe8bb89a454/ansi_on",
-      "reason": "SELECT ifnull(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#bfe8bb89a454/ansi_off",
-      "reason": "SELECT ifnull(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#c4bb34dbeb36/ansi_on",
-      "reason": "SELECT ifnull(1, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#c4bb34dbeb36/ansi_off",
-      "reason": "SELECT ifnull(1, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "ifnull#ca112c5b4ed3/ansi_on",
       "reason": "SELECT ifnull(NULL, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -192,14 +40,6 @@
       "id": "ifnull#d7660483e606/ansi_off",
       "reason": "SELECT ifnull(NULL, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map"
     },
-    {
-      "id": "ifnull#d840be61918f/ansi_on",
-      "reason": "SELECT ifnull(array(1, 2), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "ifnull#d840be61918f/ansi_off",
-      "reason": "SELECT ifnull(array(1, 2), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "ifnull#e500a975bbe1/ansi_on",
       "reason": "SELECT ifnull(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -207,14 +47,6 @@
     {
       "id": "ifnull#e500a975bbe1/ansi_off",
       "reason": "SELECT ifnull(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "ifnull#f5e830f1e7fe/ansi_on",
-      "reason": "SELECT ifnull(CAST(1.5 AS DECIMAL(38,18)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "ifnull#f5e830f1e7fe/ansi_off",
-      "reason": "SELECT ifnull(CAST(1.5 AS DECIMAL(38,18)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/initcap.json b/tests/fixtures/analysis/registry-matrix/initcap.json
index e48c963e8..8bc0555f4 100644
--- a/tests/fixtures/analysis/registry-matrix/initcap.json
+++ b/tests/fixtures/analysis/registry-matrix/initcap.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "initcap#39ec15b89222/ansi_on",
-      "reason": "SELECT initcap(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "initcap#39ec15b89222/ansi_off",
-      "reason": "SELECT initcap(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "initcap#44cff88f8f59/ansi_on",
       "reason": "SELECT initcap(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/instr.json b/tests/fixtures/analysis/registry-matrix/instr.json
index 70efa56f7..d58988e78 100644
--- a/tests/fixtures/analysis/registry-matrix/instr.json
+++ b/tests/fixtures/analysis/registry-matrix/instr.json
@@ -16,14 +16,6 @@
       "id": "instr#3baa87298de6/ansi_off",
       "reason": "SELECT instr(INTERVAL '1 02:03:04' DAY TO SECOND, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "instr#41aefc85ac78/ansi_on",
-      "reason": "SELECT instr('SparkSQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "instr#41aefc85ac78/ansi_off",
-      "reason": "SELECT instr('SparkSQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "instr#5ed8b1a7d582/ansi_on",
       "reason": "SELECT instr('SparkSQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -32,14 +24,6 @@
       "id": "instr#5ed8b1a7d582/ansi_off",
       "reason": "SELECT instr('SparkSQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "instr#81e5b1b5edfc/ansi_on",
-      "reason": "SELECT instr(array(1, 2), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "instr#81e5b1b5edfc/ansi_off",
-      "reason": "SELECT instr(array(1, 2), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "instr#ca28524036fb/ansi_on",
       "reason": "SELECT instr(map('a', 1), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/is_valid_utf8.json b/tests/fixtures/analysis/registry-matrix/is_valid_utf8.json
index b344c9797..3e344449a 100644
--- a/tests/fixtures/analysis/registry-matrix/is_valid_utf8.json
+++ b/tests/fixtures/analysis/registry-matrix/is_valid_utf8.json
@@ -23,14 +23,6 @@
     {
       "id": "is_valid_utf8#471e1888f6c8/ansi_off",
       "reason": "SELECT is_valid_utf8(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "is_valid_utf8#c6ecf8beba2a/ansi_on",
-      "reason": "SELECT is_valid_utf8(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "is_valid_utf8#c6ecf8beba2a/ansi_off",
-      "reason": "SELECT is_valid_utf8(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/isnan.json b/tests/fixtures/analysis/registry-matrix/isnan.json
index 7c8dd737f..d1a19d895 100644
--- a/tests/fixtures/analysis/registry-matrix/isnan.json
+++ b/tests/fixtures/analysis/registry-matrix/isnan.json
@@ -16,14 +16,6 @@
       "id": "isnan#29e561a2c026/ansi_off",
       "reason": "SELECT isnan(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "isnan#6aaa7975e1b0/ansi_on",
-      "reason": "SELECT isnan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "isnan#6aaa7975e1b0/ansi_off",
-      "reason": "SELECT isnan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "isnan#f996f90ad990/ansi_on",
       "reason": "SELECT isnan(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/isnotnull.json b/tests/fixtures/analysis/registry-matrix/isnotnull.json
index 552bc35c7..a5589fc29 100644
--- a/tests/fixtures/analysis/registry-matrix/isnotnull.json
+++ b/tests/fixtures/analysis/registry-matrix/isnotnull.json
@@ -23,14 +23,6 @@
     {
       "id": "isnotnull#72997046ecf4/ansi_off",
       "reason": "SELECT isnotnull(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "isnotnull#bf55c5b9fec9/ansi_on",
-      "reason": "SELECT isnotnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "isnotnull#bf55c5b9fec9/ansi_off",
-      "reason": "SELECT isnotnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/isnull.json b/tests/fixtures/analysis/registry-matrix/isnull.json
index 43efbd129..4b10cc1c6 100644
--- a/tests/fixtures/analysis/registry-matrix/isnull.json
+++ b/tests/fixtures/analysis/registry-matrix/isnull.json
@@ -16,14 +16,6 @@
       "id": "isnull#2013e66b962e/ansi_off",
       "reason": "SELECT isnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map"
     },
-    {
-      "id": "isnull#3b045f12ca67/ansi_on",
-      "reason": "SELECT isnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "isnull#3b045f12ca67/ansi_off",
-      "reason": "SELECT isnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "isnull#56c254dd036b/ansi_on",
       "reason": "SELECT isnull(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/last.json b/tests/fixtures/analysis/registry-matrix/last.json
index f61d3d658..7c0ae4b4c 100644
--- a/tests/fixtures/analysis/registry-matrix/last.json
+++ b/tests/fixtures/analysis/registry-matrix/last.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "last#14e29c30b9be/ansi_on",
-      "reason": "SELECT last(col, array(1, 2)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210"
-    },
-    {
-      "id": "last#14e29c30b9be/ansi_off",
-      "reason": "SELECT last(col, array(1, 2)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210"
-    },
     {
       "id": "last#63f16e2e35b3/ansi_on",
       "reason": "SELECT last(col, INTERVAL '1-2' YEAR TO MONTH) FROM VALUES (10), (5), (NULL) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210"
diff --git a/tests/fixtures/analysis/registry-matrix/last_day.json b/tests/fixtures/analysis/registry-matrix/last_day.json
index dc51d27dd..24aafe842 100644
--- a/tests/fixtures/analysis/registry-matrix/last_day.json
+++ b/tests/fixtures/analysis/registry-matrix/last_day.json
@@ -16,14 +16,6 @@
       "id": "last_day#6952126118a9/ansi_off",
       "reason": "SELECT last_day(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "last_day#93f4e80f80b9/ansi_on",
-      "reason": "SELECT last_day(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "last_day#93f4e80f80b9/ansi_off",
-      "reason": "SELECT last_day(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "last_day#ccb5b77f56ff/ansi_on",
       "reason": "SELECT last_day(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/last_value.json b/tests/fixtures/analysis/registry-matrix/last_value.json
index bdbfbfbd5..2a1cbc388 100644
--- a/tests/fixtures/analysis/registry-matrix/last_value.json
+++ b/tests/fixtures/analysis/registry-matrix/last_value.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "last_value#2b628baff52d/ansi_on",
-      "reason": "SELECT last_value(col, array(1, 2)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210"
-    },
-    {
-      "id": "last_value#2b628baff52d/ansi_off",
-      "reason": "SELECT last_value(col, array(1, 2)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210"
-    },
     {
       "id": "last_value#59116f565aa7/ansi_on",
       "reason": "SELECT last_value(col, map('a', 1)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210"
diff --git a/tests/fixtures/analysis/registry-matrix/lcase.json b/tests/fixtures/analysis/registry-matrix/lcase.json
index 85c9f74af..f3642d738 100644
--- a/tests/fixtures/analysis/registry-matrix/lcase.json
+++ b/tests/fixtures/analysis/registry-matrix/lcase.json
@@ -8,14 +8,6 @@
       "id": "lcase#5f8ebfb97b33/ansi_off",
       "reason": "SELECT lcase(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "lcase#77b7ee7da5a4/ansi_on",
-      "reason": "SELECT lcase(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lcase#77b7ee7da5a4/ansi_off",
-      "reason": "SELECT lcase(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "lcase#a43c0260bd5e/ansi_on",
       "reason": "SELECT lcase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/least.json b/tests/fixtures/analysis/registry-matrix/least.json
index 038382d60..0ee928d2b 100644
--- a/tests/fixtures/analysis/registry-matrix/least.json
+++ b/tests/fixtures/analysis/registry-matrix/least.json
@@ -24,14 +24,6 @@
       "id": "least#3109c3554932/ansi_off",
       "reason": "SELECT least(10, 9, 2, INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "least#4bc4ee9d81f5/ansi_on",
-      "reason": "SELECT least(10, 9, array(1, 2), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#4bc4ee9d81f5/ansi_off",
-      "reason": "SELECT least(10, 9, array(1, 2), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "least#4ded5ea86b66/ansi_on",
       "reason": "SELECT least(10, INTERVAL '1-2' YEAR TO MONTH, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -80,22 +72,6 @@
       "id": "least#73730af25057/ansi_off",
       "reason": "SELECT least(10, 9, 2, INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "least#7bf55f7932df/ansi_on",
-      "reason": "SELECT least(array(1, 2), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#7bf55f7932df/ansi_off",
-      "reason": "SELECT least(array(1, 2), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#7e2c5fcaa68d/ansi_on",
-      "reason": "SELECT least(10, 9, 2, 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#7e2c5fcaa68d/ansi_off",
-      "reason": "SELECT least(10, 9, 2, 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "least#803606ea5b42/ansi_on",
       "reason": "SELECT least(10, 9, INTERVAL '1-2' YEAR TO MONTH, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -112,14 +88,6 @@
       "id": "least#844d108891b5/ansi_off",
       "reason": "SELECT least(10, 9, 2, 4, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "least#b278e45a69a6/ansi_on",
-      "reason": "SELECT least(10, array(1, 2), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#b278e45a69a6/ansi_off",
-      "reason": "SELECT least(10, array(1, 2), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "least#c9491beacab8/ansi_on",
       "reason": "SELECT least(10, INTERVAL '1 02:03:04' DAY TO SECOND, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -144,14 +112,6 @@
       "id": "least#eb6e2c2c1be6/ansi_off",
       "reason": "SELECT least(10, map('a', 1), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "least#ee82fb8da979/ansi_on",
-      "reason": "SELECT least(10, 9, 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#ee82fb8da979/ansi_off",
-      "reason": "SELECT least(10, 9, 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "least#f966d17db1a4/ansi_on",
       "reason": "SELECT least(10, 9, 2, 4, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
diff --git a/tests/fixtures/analysis/registry-matrix/left.json b/tests/fixtures/analysis/registry-matrix/left.json
index 89639b269..f39bfbb19 100644
--- a/tests/fixtures/analysis/registry-matrix/left.json
+++ b/tests/fixtures/analysis/registry-matrix/left.json
@@ -1,21 +1,5 @@
 {
   "entries": [
-    {
-      "id": "left#1b40b06bf9ee/ansi_on",
-      "reason": "SELECT left('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "left#1b40b06bf9ee/ansi_off",
-      "reason": "SELECT left('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "left#24b0544fefb4/ansi_on",
-      "reason": "SELECT left(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "left#24b0544fefb4/ansi_off",
-      "reason": "SELECT left(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "left#2507b987e753/ansi_on",
       "reason": "SELECT left(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/len.json b/tests/fixtures/analysis/registry-matrix/len.json
index 6fb4b8ce8..a8d9f5803 100644
--- a/tests/fixtures/analysis/registry-matrix/len.json
+++ b/tests/fixtures/analysis/registry-matrix/len.json
@@ -8,14 +8,6 @@
       "id": "len#0dc71cd27cae/ansi_off",
       "reason": "SELECT len(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "len#2964b99ee7e5/ansi_on",
-      "reason": "SELECT len(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "len#2964b99ee7e5/ansi_off",
-      "reason": "SELECT len(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "len#89747546a701/ansi_on",
       "reason": "SELECT len(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/length.json b/tests/fixtures/analysis/registry-matrix/length.json
index 4ca673bd4..4df3bd90c 100644
--- a/tests/fixtures/analysis/registry-matrix/length.json
+++ b/tests/fixtures/analysis/registry-matrix/length.json
@@ -8,14 +8,6 @@
       "id": "length#3850ba7284e8/ansi_off",
       "reason": "SELECT length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "length#55ae664eebe8/ansi_on",
-      "reason": "SELECT length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "length#55ae664eebe8/ansi_off",
-      "reason": "SELECT length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "length#c112063cc572/ansi_on",
       "reason": "SELECT length(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/levenshtein.json b/tests/fixtures/analysis/registry-matrix/levenshtein.json
index 0fb128e27..b131f6f1f 100644
--- a/tests/fixtures/analysis/registry-matrix/levenshtein.json
+++ b/tests/fixtures/analysis/registry-matrix/levenshtein.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "levenshtein#1ca3389cfad5/ansi_on",
-      "reason": "SELECT levenshtein(array(1, 2), 'sitting') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "levenshtein#1ca3389cfad5/ansi_off",
-      "reason": "SELECT levenshtein(array(1, 2), 'sitting') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "levenshtein#1f75a6646bcf/ansi_on",
       "reason": "SELECT levenshtein('kitten', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -56,14 +48,6 @@
       "id": "levenshtein#53b471b728dc/ansi_off",
       "reason": "SELECT levenshtein('kitten', 'sitting', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "levenshtein#5ebf7eaa9faa/ansi_on",
-      "reason": "SELECT levenshtein('kitten', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "levenshtein#5ebf7eaa9faa/ansi_off",
-      "reason": "SELECT levenshtein('kitten', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "levenshtein#8bc15785b8fe/ansi_on",
       "reason": "SELECT levenshtein(INTERVAL '1-2' YEAR TO MONTH, 'sitting') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -112,14 +96,6 @@
       "id": "levenshtein#ab0b77246dee/ansi_off",
       "reason": "SELECT levenshtein('kitten', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "levenshtein#b15f7cc0589a/ansi_on",
-      "reason": "SELECT levenshtein('kitten', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "levenshtein#b15f7cc0589a/ansi_off",
-      "reason": "SELECT levenshtein('kitten', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "levenshtein#b19d7855506e/ansi_on",
       "reason": "SELECT levenshtein(map('a', 1), 'sitting', 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -128,14 +104,6 @@
       "id": "levenshtein#b19d7855506e/ansi_off",
       "reason": "SELECT levenshtein(map('a', 1), 'sitting', 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "levenshtein#bb27fbb7bef8/ansi_on",
-      "reason": "SELECT levenshtein('kitten', 'sitting', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "levenshtein#bb27fbb7bef8/ansi_off",
-      "reason": "SELECT levenshtein('kitten', 'sitting', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "levenshtein#ca49decba07e/ansi_on",
       "reason": "SELECT levenshtein(INTERVAL '1 02:03:04' DAY TO SECOND, 'sitting') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -144,14 +112,6 @@
       "id": "levenshtein#ca49decba07e/ansi_off",
       "reason": "SELECT levenshtein(INTERVAL '1 02:03:04' DAY TO SECOND, 'sitting') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "levenshtein#d848c5657a1c/ansi_on",
-      "reason": "SELECT levenshtein(array(1, 2), 'sitting', 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "levenshtein#d848c5657a1c/ansi_off",
-      "reason": "SELECT levenshtein(array(1, 2), 'sitting', 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "levenshtein#eb13bb49b1b9/ansi_on",
       "reason": "SELECT levenshtein(INTERVAL '1 02:03:04' DAY TO SECOND, 'sitting', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/ln.json b/tests/fixtures/analysis/registry-matrix/ln.json
index fbffaeb4c..691c981a6 100644
--- a/tests/fixtures/analysis/registry-matrix/ln.json
+++ b/tests/fixtures/analysis/registry-matrix/ln.json
@@ -8,14 +8,6 @@
       "id": "ln#a4fd4a2aae22/ansi_off",
       "reason": "SELECT ln(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ln#b3f8340799d9/ansi_on",
-      "reason": "SELECT ln(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ln#b3f8340799d9/ansi_off",
-      "reason": "SELECT ln(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ln#e46d79f0541d/ansi_on",
       "reason": "SELECT ln(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/locate.json b/tests/fixtures/analysis/registry-matrix/locate.json
index 7c7058cc0..fea2eed8c 100644
--- a/tests/fixtures/analysis/registry-matrix/locate.json
+++ b/tests/fixtures/analysis/registry-matrix/locate.json
@@ -16,22 +16,6 @@
       "id": "locate#0c58b38c3b6d/ansi_off",
       "reason": "SELECT locate('bar', 'foobarbar', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "locate#12a673982c42/ansi_on",
-      "reason": "SELECT locate('bar', array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "locate#12a673982c42/ansi_off",
-      "reason": "SELECT locate('bar', array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "locate#17ea48769b02/ansi_on",
-      "reason": "SELECT locate(array(1, 2), 'foobarbar', 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "locate#17ea48769b02/ansi_off",
-      "reason": "SELECT locate(array(1, 2), 'foobarbar', 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "locate#2aaf54a57aca/ansi_on",
       "reason": "SELECT locate('bar', 'foobarbar', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,14 +24,6 @@
       "id": "locate#2aaf54a57aca/ansi_off",
       "reason": "SELECT locate('bar', 'foobarbar', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "locate#4fa9f9124d9a/ansi_on",
-      "reason": "SELECT locate('bar', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "locate#4fa9f9124d9a/ansi_off",
-      "reason": "SELECT locate('bar', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "locate#5f5842f91add/ansi_on",
       "reason": "SELECT locate(INTERVAL '1-2' YEAR TO MONTH, 'foobarbar') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -72,14 +48,6 @@
       "id": "locate#7e29689f2553/ansi_off",
       "reason": "SELECT locate(INTERVAL '1 02:03:04' DAY TO SECOND, 'foobarbar', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "locate#8ac13eee16f4/ansi_on",
-      "reason": "SELECT locate('bar', 'foobarbar', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "locate#8ac13eee16f4/ansi_off",
-      "reason": "SELECT locate('bar', 'foobarbar', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "locate#908e65ca359a/ansi_on",
       "reason": "SELECT locate(INTERVAL '1-2' YEAR TO MONTH, 'foobarbar', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -144,14 +112,6 @@
       "id": "locate#f4332c0ebfcb/ansi_off",
       "reason": "SELECT locate('bar', map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "locate#fb53f0a3db5f/ansi_on",
-      "reason": "SELECT locate(array(1, 2), 'foobarbar') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "locate#fb53f0a3db5f/ansi_off",
-      "reason": "SELECT locate(array(1, 2), 'foobarbar') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "locate#ffc3f838bcdf/ansi_on",
       "reason": "SELECT locate(INTERVAL '1 02:03:04' DAY TO SECOND, 'foobarbar') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/log.json b/tests/fixtures/analysis/registry-matrix/log.json
index c4738fa6c..7cd282f35 100644
--- a/tests/fixtures/analysis/registry-matrix/log.json
+++ b/tests/fixtures/analysis/registry-matrix/log.json
@@ -8,14 +8,6 @@
       "id": "log#2849851ffff9/ansi_off",
       "reason": "SELECT log(10, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "log#5c08d869324e/ansi_on",
-      "reason": "SELECT log(10, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log#5c08d869324e/ansi_off",
-      "reason": "SELECT log(10, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "log#6e4cd2e20dbf/ansi_on",
       "reason": "SELECT log(10, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -32,14 +24,6 @@
       "id": "log#94eb25460542/ansi_off",
       "reason": "SELECT log(map('a', 1), 100) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "log#97df9415f277/ansi_on",
-      "reason": "SELECT log(array(1, 2), 100) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log#97df9415f277/ansi_off",
-      "reason": "SELECT log(array(1, 2), 100) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "log#b29ab2f7e498/ansi_on",
       "reason": "SELECT log(INTERVAL '1 02:03:04' DAY TO SECOND, 100) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/log10.json b/tests/fixtures/analysis/registry-matrix/log10.json
index f69540e16..d9e5e16ee 100644
--- a/tests/fixtures/analysis/registry-matrix/log10.json
+++ b/tests/fixtures/analysis/registry-matrix/log10.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "log10#0ed43d169a69/ansi_on",
-      "reason": "SELECT log10(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log10#0ed43d169a69/ansi_off",
-      "reason": "SELECT log10(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "log10#3f6a0f6d439f/ansi_on",
       "reason": "SELECT log10(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/log1p.json b/tests/fixtures/analysis/registry-matrix/log1p.json
index 4b4befa99..819f82863 100644
--- a/tests/fixtures/analysis/registry-matrix/log1p.json
+++ b/tests/fixtures/analysis/registry-matrix/log1p.json
@@ -16,14 +16,6 @@
       "id": "log1p#862526b1964b/ansi_off",
       "reason": "SELECT log1p(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "log1p#c2048815afbc/ansi_on",
-      "reason": "SELECT log1p(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log1p#c2048815afbc/ansi_off",
-      "reason": "SELECT log1p(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "log1p#e515b0029715/ansi_on",
       "reason": "SELECT log1p(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/log2.json b/tests/fixtures/analysis/registry-matrix/log2.json
index 0eb57e559..5ff2252b6 100644
--- a/tests/fixtures/analysis/registry-matrix/log2.json
+++ b/tests/fixtures/analysis/registry-matrix/log2.json
@@ -23,14 +23,6 @@
     {
       "id": "log2#bbf88b925e49/ansi_off",
       "reason": "SELECT log2(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log2#dac3f570d59f/ansi_on",
-      "reason": "SELECT log2(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log2#dac3f570d59f/ansi_off",
-      "reason": "SELECT log2(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/lower.json b/tests/fixtures/analysis/registry-matrix/lower.json
index db966d77b..87a610cc6 100644
--- a/tests/fixtures/analysis/registry-matrix/lower.json
+++ b/tests/fixtures/analysis/registry-matrix/lower.json
@@ -16,14 +16,6 @@
       "id": "lower#3bb228f7d65c/ansi_off",
       "reason": "SELECT lower(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "lower#4feea7924ff5/ansi_on",
-      "reason": "SELECT lower(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lower#4feea7924ff5/ansi_off",
-      "reason": "SELECT lower(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "lower#f2581497b448/ansi_on",
       "reason": "SELECT lower(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/lpad.json b/tests/fixtures/analysis/registry-matrix/lpad.json
index 7da088b60..7cf0a5260 100644
--- a/tests/fixtures/analysis/registry-matrix/lpad.json
+++ b/tests/fixtures/analysis/registry-matrix/lpad.json
@@ -1,21 +1,5 @@
 {
   "entries": [
-    {
-      "id": "lpad#16dc5b3fef4f/ansi_on",
-      "reason": "SELECT lpad('hi', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#16dc5b3fef4f/ansi_off",
-      "reason": "SELECT lpad('hi', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#2b87c9084c86/ansi_on",
-      "reason": "SELECT lpad('hi', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#2b87c9084c86/ansi_off",
-      "reason": "SELECT lpad('hi', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "lpad#2ec7eb553107/ansi_on",
       "reason": "SELECT lpad(INTERVAL '1-2' YEAR TO MONTH, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -24,14 +8,6 @@
       "id": "lpad#2ec7eb553107/ansi_off",
       "reason": "SELECT lpad(INTERVAL '1-2' YEAR TO MONTH, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "lpad#36216c6c2a17/ansi_on",
-      "reason": "SELECT lpad(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#36216c6c2a17/ansi_off",
-      "reason": "SELECT lpad(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "lpad#39b23190194f/ansi_on",
       "reason": "SELECT lpad('hi', 5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -48,14 +24,6 @@
       "id": "lpad#410a80e8c9ac/ansi_off",
       "reason": "SELECT lpad('hi', INTERVAL '1 02:03:04' DAY TO SECOND, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "lpad#467f5d66c343/ansi_on",
-      "reason": "SELECT lpad(array(1, 2), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#467f5d66c343/ansi_off",
-      "reason": "SELECT lpad(array(1, 2), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "lpad#60bd64d2fdce/ansi_on",
       "reason": "SELECT lpad('hi', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -72,14 +40,6 @@
       "id": "lpad#7a419bc53ab4/ansi_off",
       "reason": "SELECT lpad(map('a', 1), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "lpad#7fbbfc2d5d70/ansi_on",
-      "reason": "SELECT lpad('hi', array(1, 2), '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#7fbbfc2d5d70/ansi_off",
-      "reason": "SELECT lpad('hi', array(1, 2), '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "lpad#86f3021e158c/ansi_on",
       "reason": "SELECT lpad(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/ltrim.json b/tests/fixtures/analysis/registry-matrix/ltrim.json
index 82f233851..d10627540 100644
--- a/tests/fixtures/analysis/registry-matrix/ltrim.json
+++ b/tests/fixtures/analysis/registry-matrix/ltrim.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "ltrim#1619a3484678/ansi_on",
-      "reason": "SELECT ltrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ltrim#1619a3484678/ansi_off",
-      "reason": "SELECT ltrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ltrim#6225b3289404/ansi_on",
       "reason": "SELECT ltrim(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/luhn_check.json b/tests/fixtures/analysis/registry-matrix/luhn_check.json
index 002d6a868..08a313972 100644
--- a/tests/fixtures/analysis/registry-matrix/luhn_check.json
+++ b/tests/fixtures/analysis/registry-matrix/luhn_check.json
@@ -23,14 +23,6 @@
     {
       "id": "luhn_check#8b95c9c9acc1/ansi_off",
       "reason": "SELECT luhn_check(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "luhn_check#a6c3ee9d1cad/ansi_on",
-      "reason": "SELECT luhn_check(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "luhn_check#a6c3ee9d1cad/ansi_off",
-      "reason": "SELECT luhn_check(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/make_date.json b/tests/fixtures/analysis/registry-matrix/make_date.json
index 59a13e36c..ea615da5c 100644
--- a/tests/fixtures/analysis/registry-matrix/make_date.json
+++ b/tests/fixtures/analysis/registry-matrix/make_date.json
@@ -56,22 +56,6 @@
       "id": "make_date#65c3a9e68abf/ansi_off",
       "reason": "SELECT make_date(map('a', 1), 7, 15) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "make_date#670b553cefcd/ansi_on",
-      "reason": "SELECT make_date(2013, array(1, 2), 15) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "make_date#670b553cefcd/ansi_off",
-      "reason": "SELECT make_date(2013, array(1, 2), 15) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "make_date#71717f95eb32/ansi_on",
-      "reason": "SELECT make_date(2013, 7, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "make_date#71717f95eb32/ansi_off",
-      "reason": "SELECT make_date(2013, 7, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "make_date#dc2fc7038c2e/ansi_on",
       "reason": "SELECT make_date(2013, 7, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -87,14 +71,6 @@
     {
       "id": "make_date#df298d18b826/ansi_off",
       "reason": "SELECT make_date(INTERVAL '1-2' YEAR TO MONTH, 7, 15) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "make_date#e5d50aae8051/ansi_on",
-      "reason": "SELECT make_date(array(1, 2), 7, 15) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "make_date#e5d50aae8051/ansi_off",
-      "reason": "SELECT make_date(array(1, 2), 7, 15) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/make_valid_utf8.json b/tests/fixtures/analysis/registry-matrix/make_valid_utf8.json
index 52d7c60d6..ee1154f16 100644
--- a/tests/fixtures/analysis/registry-matrix/make_valid_utf8.json
+++ b/tests/fixtures/analysis/registry-matrix/make_valid_utf8.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "make_valid_utf8#50a878ed6a15/ansi_on",
-      "reason": "SELECT make_valid_utf8(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "make_valid_utf8#50a878ed6a15/ansi_off",
-      "reason": "SELECT make_valid_utf8(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "make_valid_utf8#6ebcc233980a/ansi_on",
       "reason": "SELECT make_valid_utf8(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/mask.json b/tests/fixtures/analysis/registry-matrix/mask.json
index 0646e4e49..f419284a0 100644
--- a/tests/fixtures/analysis/registry-matrix/mask.json
+++ b/tests/fixtures/analysis/registry-matrix/mask.json
@@ -56,22 +56,6 @@
       "id": "mask#1c8ecfa526a9/ansi_off",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "mask#1d7d64d5b30c/ansi_on",
-      "reason": "SELECT mask(array(1, 2), 'Q', 'q', 'd') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#1d7d64d5b30c/ansi_off",
-      "reason": "SELECT mask(array(1, 2), 'Q', 'q', 'd') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#1f4d944bf49b/ansi_on",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#1f4d944bf49b/ansi_off",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#268098ca5d12/ansi_on",
       "reason": "SELECT mask('AbCD123-@$#', CAST(X'C328FF' AS STRING), 'q') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.INPUT_SIZE_NOT_ONE"
@@ -96,14 +80,6 @@
       "id": "mask#27cb2dfd4b84/ansi_off",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "mask#2f15a78ccb47/ansi_on",
-      "reason": "SELECT mask('AbCD123-@$#', array(1, 2), 'q', 'd') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#2f15a78ccb47/ansi_off",
-      "reason": "SELECT mask('AbCD123-@$#', array(1, 2), 'q', 'd') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#2f388b8a41ca/ansi_on",
       "reason": "SELECT mask('', 'Q', 'q', 'd', 'o') | string not null where Spark has string"
@@ -112,22 +88,6 @@
       "id": "mask#2f388b8a41ca/ansi_off",
       "reason": "SELECT mask('', 'Q', 'q', 'd', 'o') | string not null where Spark has string"
     },
-    {
-      "id": "mask#2f95d65db220/ansi_on",
-      "reason": "SELECT mask('AbCD123-@$#', array(1, 2), 'q') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#2f95d65db220/ansi_off",
-      "reason": "SELECT mask('AbCD123-@$#', array(1, 2), 'q') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#31f94169c574/ansi_on",
-      "reason": "SELECT mask(array(1, 2), 'Q') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#31f94169c574/ansi_off",
-      "reason": "SELECT mask(array(1, 2), 'Q') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#32a541e4c9d1/ansi_on",
       "reason": "SELECT mask(map('a', 1), 'Q', 'q') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -160,14 +120,6 @@
       "id": "mask#38471fc72bbc/ansi_off",
       "reason": "SELECT mask(' \\t a\\u3000\\n ', 'Q', 'q', 'd', 'o') | string not null where Spark has string"
     },
-    {
-      "id": "mask#3a40e57c1295/ansi_on",
-      "reason": "SELECT mask('AbCD123-@$#', array(1, 2), 'q', 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#3a40e57c1295/ansi_off",
-      "reason": "SELECT mask('AbCD123-@$#', array(1, 2), 'q', 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#3ae6027968be/ansi_on",
       "reason": "SELECT mask(INTERVAL '1 02:03:04' DAY TO SECOND, 'Q') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -224,14 +176,6 @@
       "id": "mask#4c3bbabdc2d6/ansi_off",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "mask#4fffbb92ffbe/ansi_on",
-      "reason": "SELECT mask(array(1, 2), 'Q', 'q', 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#4fffbb92ffbe/ansi_off",
-      "reason": "SELECT mask(array(1, 2), 'Q', 'q', 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#6691f60de573/ansi_on",
       "reason": "SELECT mask('abcd-EFGH-8765-4321', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -280,14 +224,6 @@
       "id": "mask#6df05562a7c6/ansi_off",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', CAST(X'C328FF' AS STRING), 'd', 'o') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.INPUT_SIZE_NOT_ONE"
     },
-    {
-      "id": "mask#7a747dbeb68b/ansi_on",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', array(1, 2), 'd') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#7a747dbeb68b/ansi_off",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', array(1, 2), 'd') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#7af2934fee03/ansi_on",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -328,14 +264,6 @@
       "id": "mask#7f4b1175ebb0/ansi_off",
       "reason": "SELECT mask(map('a', 1), 'Q') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "mask#8083dc23d5f1/ansi_on",
-      "reason": "SELECT mask(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#8083dc23d5f1/ansi_off",
-      "reason": "SELECT mask(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#81733105ced5/ansi_on",
       "reason": "SELECT mask('abcd-EFGH-8765-4321', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -344,14 +272,6 @@
       "id": "mask#81733105ced5/ansi_off",
       "reason": "SELECT mask('abcd-EFGH-8765-4321', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "mask#8d77fa2b7b92/ansi_on",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', array(1, 2), 'o') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#8d77fa2b7b92/ansi_off",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', array(1, 2), 'o') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#8e073509fa76/ansi_on",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -376,22 +296,6 @@
       "id": "mask#94cbcce5e38e/ansi_off",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', INTERVAL '1-2' YEAR TO MONTH, 'd') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "mask#95b34ca14dae/ansi_on",
-      "reason": "SELECT mask(array(1, 2), 'Q', 'q') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#95b34ca14dae/ansi_off",
-      "reason": "SELECT mask(array(1, 2), 'Q', 'q') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#966ffe59aebf/ansi_on",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', array(1, 2), 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#966ffe59aebf/ansi_off",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', array(1, 2), 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#9dc44bff3e50/ansi_on",
       "reason": "SELECT mask('abcd-EFGH-8765-4321', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -416,14 +320,6 @@
       "id": "mask#a045760f7cbb/ansi_off",
       "reason": "SELECT mask('AbCD123-@$#', INTERVAL '1 02:03:04' DAY TO SECOND, 'q', 'd') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "mask#a184b757e96d/ansi_on",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#a184b757e96d/ansi_off",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#a2228ad6d6e9/ansi_on",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -448,14 +344,6 @@
       "id": "mask#a523765f14c7/ansi_off",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o') | string not null where Spark has string"
     },
-    {
-      "id": "mask#a5481ebc1b9a/ansi_on",
-      "reason": "SELECT mask('abcd-EFGH-8765-4321', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#a5481ebc1b9a/ansi_off",
-      "reason": "SELECT mask('abcd-EFGH-8765-4321', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#a6e0d300e1cd/ansi_on",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', CAST(X'C328FF' AS STRING), 'd') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.INPUT_SIZE_NOT_ONE"
@@ -616,14 +504,6 @@
       "id": "mask#ef30e035841e/ansi_off",
       "reason": "SELECT mask(INTERVAL '1-2' YEAR TO MONTH, 'Q') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "mask#f0ad8615a5c7/ansi_on",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "mask#f0ad8615a5c7/ansi_off",
-      "reason": "SELECT mask('AbCD123-@$#', 'Q', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "mask#f2eae03490ae/ansi_on",
       "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', CAST(X'C328FF' AS STRING)) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.INPUT_SIZE_NOT_ONE"
diff --git a/tests/fixtures/analysis/registry-matrix/max_by.json b/tests/fixtures/analysis/registry-matrix/max_by.json
index 7d515f50f..24fc550bc 100644
--- a/tests/fixtures/analysis/registry-matrix/max_by.json
+++ b/tests/fixtures/analysis/registry-matrix/max_by.json
@@ -186,11 +186,11 @@
     },
     {
       "id": "max_by#f0872159688c/ansi_on",
-      "reason": "SELECT max_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT max_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "max_by#f0872159688c/ansi_off",
-      "reason": "SELECT max_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT max_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "max_by#ff115f23cf8f/ansi_on",
diff --git a/tests/fixtures/analysis/registry-matrix/md5.json b/tests/fixtures/analysis/registry-matrix/md5.json
index 80ee19b0b..9bf2bdd7e 100644
--- a/tests/fixtures/analysis/registry-matrix/md5.json
+++ b/tests/fixtures/analysis/registry-matrix/md5.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "md5#494fc1423cbf/ansi_on",
-      "reason": "SELECT md5(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "md5#494fc1423cbf/ansi_off",
-      "reason": "SELECT md5(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "md5#9692b66cda2b/ansi_on",
       "reason": "SELECT md5(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/min_by.json b/tests/fixtures/analysis/registry-matrix/min_by.json
index 4b4bb2ffc..9833f6fbc 100644
--- a/tests/fixtures/analysis/registry-matrix/min_by.json
+++ b/tests/fixtures/analysis/registry-matrix/min_by.json
@@ -90,11 +90,11 @@
     },
     {
       "id": "min_by#80d0ca30807a/ansi_on",
-      "reason": "SELECT min_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT min_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "min_by#80d0ca30807a/ansi_off",
-      "reason": "SELECT min_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT min_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "min_by#897e17cdfb93/ansi_on",
diff --git a/tests/fixtures/analysis/registry-matrix/minute.json b/tests/fixtures/analysis/registry-matrix/minute.json
index e3018b85b..77447b339 100644
--- a/tests/fixtures/analysis/registry-matrix/minute.json
+++ b/tests/fixtures/analysis/registry-matrix/minute.json
@@ -8,14 +8,6 @@
       "id": "minute#4480f918603c/ansi_off",
       "reason": "SELECT minute(CAST(NULL AS time(6))) | parse: KRISHIV_UNSUPPORTED_FEATURE: the time data type (\"TIME\") where Spark has UNSUPPORTED_TIME_TYPE"
     },
-    {
-      "id": "minute#73d04a408bd8/ansi_on",
-      "reason": "SELECT minute(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "minute#73d04a408bd8/ansi_off",
-      "reason": "SELECT minute(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "minute#7dda78084d4d/ansi_on",
       "reason": "SELECT minute(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/mod.json b/tests/fixtures/analysis/registry-matrix/mod.json
index d67a081dc..4d22cc670 100644
--- a/tests/fixtures/analysis/registry-matrix/mod.json
+++ b/tests/fixtures/analysis/registry-matrix/mod.json
@@ -28,14 +28,6 @@
       "id": "mod#4fa2d83805ae/ansi_off",
       "reason": "SELECT MOD('abc', 1.8) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "mod#50bf39e335f1/ansi_on",
-      "reason": "SELECT MOD(array(1, 2), 1.8) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "mod#50bf39e335f1/ansi_off",
-      "reason": "SELECT MOD(array(1, 2), 1.8) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "mod#5fe5533591e7/ansi_on",
       "reason": "SELECT MOD(INTERVAL '1-2' YEAR TO MONTH, 1.8) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -71,14 +63,6 @@
     {
       "id": "mod#c846ac62379a/ansi_off",
       "reason": "SELECT MOD(2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "mod#d3dc388a8ea9/ansi_on",
-      "reason": "SELECT MOD(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "mod#d3dc388a8ea9/ansi_off",
-      "reason": "SELECT MOD(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/month.json b/tests/fixtures/analysis/registry-matrix/month.json
index 8429bb368..d7e678013 100644
--- a/tests/fixtures/analysis/registry-matrix/month.json
+++ b/tests/fixtures/analysis/registry-matrix/month.json
@@ -16,14 +16,6 @@
       "id": "month#5f9cb2792de7/ansi_off",
       "reason": "SELECT month(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "month#65bec69f1710/ansi_on",
-      "reason": "SELECT month(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "month#65bec69f1710/ansi_off",
-      "reason": "SELECT month(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "month#8a56108c2560/ansi_on",
       "reason": "SELECT month(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/monthname.json b/tests/fixtures/analysis/registry-matrix/monthname.json
index 80d41b070..5eb686937 100644
--- a/tests/fixtures/analysis/registry-matrix/monthname.json
+++ b/tests/fixtures/analysis/registry-matrix/monthname.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "monthname#370266c7abd2/ansi_on",
-      "reason": "SELECT monthname(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "monthname#370266c7abd2/ansi_off",
-      "reason": "SELECT monthname(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "monthname#3de4a1bb6046/ansi_on",
       "reason": "SELECT monthname(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/months_between.json b/tests/fixtures/analysis/registry-matrix/months_between.json
index 5b0438446..15b91b0ba 100644
--- a/tests/fixtures/analysis/registry-matrix/months_between.json
+++ b/tests/fixtures/analysis/registry-matrix/months_between.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "months_between#14b4c46552c5/ansi_on",
-      "reason": "SELECT months_between(array(1, 2), '1996-10-30', false) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "months_between#14b4c46552c5/ansi_off",
-      "reason": "SELECT months_between(array(1, 2), '1996-10-30', false) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "months_between#1cf30befe281/ansi_on",
       "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -16,14 +8,6 @@
       "id": "months_between#1cf30befe281/ansi_off",
       "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "months_between#1d6c07f4a83a/ansi_on",
-      "reason": "SELECT months_between(array(1, 2), '1996-10-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "months_between#1d6c07f4a83a/ansi_off",
-      "reason": "SELECT months_between(array(1, 2), '1996-10-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "months_between#1de399a111e8/ansi_on",
       "reason": "SELECT months_between('1997-02-28 10:30:00', map('a', 1), false) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,14 +24,6 @@
       "id": "months_between#3b4d3579db12/ansi_off",
       "reason": "SELECT months_between(INTERVAL '1 02:03:04' DAY TO SECOND, '1996-10-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "months_between#41c7765d7848/ansi_on",
-      "reason": "SELECT months_between('1997-02-28 10:30:00', array(1, 2), false) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "months_between#41c7765d7848/ansi_off",
-      "reason": "SELECT months_between('1997-02-28 10:30:00', array(1, 2), false) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "months_between#4aee6056f332/ansi_on",
       "reason": "SELECT months_between('1997-02-28 10:30:00', INTERVAL '1-2' YEAR TO MONTH, false) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -76,14 +52,6 @@
       "id": "months_between#648a4a20f4e8/ansi_off",
       "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', 'abc') | resolves to double where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "months_between#6668f1e91220/ansi_on",
-      "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "months_between#6668f1e91220/ansi_off",
-      "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "months_between#6955e166bd2c/ansi_on",
       "reason": "SELECT months_between(INTERVAL '1-2' YEAR TO MONTH, '1996-10-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -136,14 +104,6 @@
       "id": "months_between#ad7e3fced174/ansi_off",
       "reason": "SELECT months_between(map('a', 1), '1996-10-30', false) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "months_between#bb82f2d9bdb8/ansi_on",
-      "reason": "SELECT months_between('1997-02-28 10:30:00', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "months_between#bb82f2d9bdb8/ansi_off",
-      "reason": "SELECT months_between('1997-02-28 10:30:00', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "months_between#c35328709bd8/ansi_on",
       "reason": "SELECT months_between(INTERVAL '1-2' YEAR TO MONTH, '1996-10-30', false) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/named_struct.json b/tests/fixtures/analysis/registry-matrix/named_struct.json
index 344787144..307eff984 100644
--- a/tests/fixtures/analysis/registry-matrix/named_struct.json
+++ b/tests/fixtures/analysis/registry-matrix/named_struct.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "named_struct#07dc5150ab06/ansi_on",
-      "reason": "SELECT named_struct(array(1, 2), 1, \"b\", 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING"
-    },
-    {
-      "id": "named_struct#07dc5150ab06/ansi_off",
-      "reason": "SELECT named_struct(array(1, 2), 1, \"b\", 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING"
-    },
     {
       "id": "named_struct#10069c1652a0/ansi_on",
       "reason": "SELECT named_struct(\"a\", 1, CAST(X'C328FF' AS STRING), 2, \"c\", 3) | DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING"
@@ -24,14 +16,6 @@
       "id": "named_struct#1b1abab9147f/ansi_off",
       "reason": "SELECT named_struct(\"a\", 1, \"b\", INTERVAL '1 02:03:04' DAY TO SECOND, \"c\", 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "named_struct#1e2f5201056d/ansi_on",
-      "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING"
-    },
-    {
-      "id": "named_struct#1e2f5201056d/ansi_off",
-      "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING"
-    },
     {
       "id": "named_struct#20cfff699118/ansi_on",
       "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, \"c\", map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map"
@@ -40,14 +24,6 @@
       "id": "named_struct#20cfff699118/ansi_off",
       "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, \"c\", map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map"
     },
-    {
-      "id": "named_struct#264847a8c6da/ansi_on",
-      "reason": "SELECT named_struct(\"a\", 1, array(1, 2), 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING"
-    },
-    {
-      "id": "named_struct#264847a8c6da/ansi_off",
-      "reason": "SELECT named_struct(\"a\", 1, array(1, 2), 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING"
-    },
     {
       "id": "named_struct#29ab846d2b3f/ansi_on",
       "reason": "SELECT named_struct(\"a\", INTERVAL '1 02:03:04' DAY TO SECOND, \"b\", 2, \"c\", 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -120,14 +96,6 @@
       "id": "named_struct#8b8c4c74babd/ansi_off",
       "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, \"c\", INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "named_struct#930d6fb1e013/ansi_on",
-      "reason": "SELECT named_struct(\"a\", array(1, 2), \"b\", 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "named_struct#930d6fb1e013/ansi_off",
-      "reason": "SELECT named_struct(\"a\", array(1, 2), \"b\", 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "named_struct#933fd3e5ff75/ansi_on",
       "reason": "SELECT named_struct(INTERVAL '1-2' YEAR TO MONTH, 1, \"b\", 2, \"c\", 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING"
@@ -136,14 +104,6 @@
       "id": "named_struct#933fd3e5ff75/ansi_off",
       "reason": "SELECT named_struct(INTERVAL '1-2' YEAR TO MONTH, 1, \"b\", 2, \"c\", 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING"
     },
-    {
-      "id": "named_struct#95267307c5c7/ansi_on",
-      "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, \"c\", array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "named_struct#95267307c5c7/ansi_off",
-      "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, \"c\", array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "named_struct#a5000dc6fc02/ansi_on",
       "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING"
@@ -160,14 +120,6 @@
       "id": "named_struct#ae007784ea32/ansi_off",
       "reason": "SELECT named_struct(\"a\", 1, \"b\", map('a', 1), \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function map"
     },
-    {
-      "id": "named_struct#b780093746ad/ansi_on",
-      "reason": "SELECT named_struct(\"a\", 1, \"b\", array(1, 2), \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "named_struct#b780093746ad/ansi_off",
-      "reason": "SELECT named_struct(\"a\", 1, \"b\", array(1, 2), \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "named_struct#c067a5924893/ansi_on",
       "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, \"c\", INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/nanvl.json b/tests/fixtures/analysis/registry-matrix/nanvl.json
index 733382e4e..26c9d0654 100644
--- a/tests/fixtures/analysis/registry-matrix/nanvl.json
+++ b/tests/fixtures/analysis/registry-matrix/nanvl.json
@@ -16,14 +16,6 @@
       "id": "nanvl#224c752cdc8a/ansi_off",
       "reason": "SELECT nanvl(map('a', 1), 123) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "nanvl#644ae139b068/ansi_on",
-      "reason": "SELECT nanvl(array(1, 2), 123) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "nanvl#644ae139b068/ansi_off",
-      "reason": "SELECT nanvl(array(1, 2), 123) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "nanvl#8c6ee640d734/ansi_on",
       "reason": "SELECT nanvl(cast('NaN' as double), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,14 +32,6 @@
       "id": "nanvl#a22c4b677583/ansi_off",
       "reason": "SELECT nanvl(INTERVAL '1-2' YEAR TO MONTH, 123) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "nanvl#cc67ce301f92/ansi_on",
-      "reason": "SELECT nanvl(cast('NaN' as double), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "nanvl#cc67ce301f92/ansi_off",
-      "reason": "SELECT nanvl(cast('NaN' as double), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "nanvl#e9d2247bde9c/ansi_on",
       "reason": "SELECT nanvl(cast('NaN' as double), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/negative.json b/tests/fixtures/analysis/registry-matrix/negative.json
index a293749da..9fd2d3f69 100644
--- a/tests/fixtures/analysis/registry-matrix/negative.json
+++ b/tests/fixtures/analysis/registry-matrix/negative.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "negative#25a8db9031cd/ansi_on",
-      "reason": "SELECT negative(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "negative#25a8db9031cd/ansi_off",
-      "reason": "SELECT negative(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "negative#987900a6d6ac/ansi_on",
       "reason": "SELECT negative(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/next_day.json b/tests/fixtures/analysis/registry-matrix/next_day.json
index fa7818b69..e2dcbe15f 100644
--- a/tests/fixtures/analysis/registry-matrix/next_day.json
+++ b/tests/fixtures/analysis/registry-matrix/next_day.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "next_day#11deac4e1b58/ansi_on",
-      "reason": "SELECT next_day(array(1, 2), 'TU') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "next_day#11deac4e1b58/ansi_off",
-      "reason": "SELECT next_day(array(1, 2), 'TU') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "next_day#180b8bb25bd8/ansi_on",
       "reason": "SELECT next_day(INTERVAL '1 02:03:04' DAY TO SECOND, 'TU') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -48,14 +40,6 @@
       "id": "next_day#a62742e67e42/ansi_off",
       "reason": "SELECT next_day(INTERVAL '1-2' YEAR TO MONTH, 'TU') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "next_day#ba75aedd3a5c/ansi_on",
-      "reason": "SELECT next_day('2015-01-14', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "next_day#ba75aedd3a5c/ansi_off",
-      "reason": "SELECT next_day('2015-01-14', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "next_day#fc48ff666ecf/ansi_on",
       "reason": "SELECT next_day('2015-01-14', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/nth_value.json b/tests/fixtures/analysis/registry-matrix/nth_value.json
index 291acadaf..43c833232 100644
--- a/tests/fixtures/analysis/registry-matrix/nth_value.json
+++ b/tests/fixtures/analysis/registry-matrix/nth_value.json
@@ -42,11 +42,11 @@
     },
     {
       "id": "nth_value#9494e9025f5d/ansi_on",
-      "reason": "SELECT a, b, nth_value(b, array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT a, b, nth_value(b, array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "nth_value#9494e9025f5d/ansi_off",
-      "reason": "SELECT a, b, nth_value(b, array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT a, b, nth_value(b, array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "nth_value#b7e9ba990e13/ansi_on",
diff --git a/tests/fixtures/analysis/registry-matrix/ntile.json b/tests/fixtures/analysis/registry-matrix/ntile.json
index 33ca29293..be33d7d35 100644
--- a/tests/fixtures/analysis/registry-matrix/ntile.json
+++ b/tests/fixtures/analysis/registry-matrix/ntile.json
@@ -2,11 +2,11 @@
   "entries": [
     {
       "id": "ntile#07ff6bea2932/ansi_on",
-      "reason": "SELECT a, b, ntile(array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT a, b, ntile(array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "ntile#07ff6bea2932/ansi_off",
-      "reason": "SELECT a, b, ntile(array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT a, b, ntile(array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "ntile#2380b319de33/ansi_on",
diff --git a/tests/fixtures/analysis/registry-matrix/nullif.json b/tests/fixtures/analysis/registry-matrix/nullif.json
index 54a078640..3b96ec914 100644
--- a/tests/fixtures/analysis/registry-matrix/nullif.json
+++ b/tests/fixtures/analysis/registry-matrix/nullif.json
@@ -1,21 +1,5 @@
 {
   "entries": [
-    {
-      "id": "nullif#14e8c8714543/ansi_on",
-      "reason": "SELECT nullif(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullif#14e8c8714543/ansi_off",
-      "reason": "SELECT nullif(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullif#1d230a3a28c9/ansi_on",
-      "reason": "SELECT nullif(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullif#1d230a3a28c9/ansi_off",
-      "reason": "SELECT nullif(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "nullif#8c6ac4b1f807/ansi_on",
       "reason": "SELECT nullif(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
diff --git a/tests/fixtures/analysis/registry-matrix/nullifzero.json b/tests/fixtures/analysis/registry-matrix/nullifzero.json
index db98a791b..5e7e1df51 100644
--- a/tests/fixtures/analysis/registry-matrix/nullifzero.json
+++ b/tests/fixtures/analysis/registry-matrix/nullifzero.json
@@ -16,14 +16,6 @@
       "id": "nullifzero#b2fca9a991cf/ansi_off",
       "reason": "SELECT nullifzero(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "nullifzero#be53c63a1268/ansi_on",
-      "reason": "SELECT nullifzero(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullifzero#be53c63a1268/ansi_off",
-      "reason": "SELECT nullifzero(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "nullifzero#f0aba72ce40b/ansi_on",
       "reason": "SELECT nullifzero(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
diff --git a/tests/fixtures/analysis/registry-matrix/nvl.json b/tests/fixtures/analysis/registry-matrix/nvl.json
index 57d55972c..c806c9ebb 100644
--- a/tests/fixtures/analysis/registry-matrix/nvl.json
+++ b/tests/fixtures/analysis/registry-matrix/nvl.json
@@ -1,29 +1,5 @@
 {
   "entries": [
-    {
-      "id": "nvl#0460fbe2242f/ansi_on",
-      "reason": "SELECT nvl(NULL, CAST(array() AS array<string>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "nvl#0460fbe2242f/ansi_off",
-      "reason": "SELECT nvl(NULL, CAST(array() AS array<string>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "nvl#07bf6900cb48/ansi_on",
-      "reason": "SELECT nvl(NULL, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "nvl#07bf6900cb48/ansi_off",
-      "reason": "SELECT nvl(NULL, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "nvl#0f4aeb376d5f/ansi_on",
-      "reason": "SELECT nvl(CAST(1.5 AS FLOAT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#0f4aeb376d5f/ansi_off",
-      "reason": "SELECT nvl(CAST(1.5 AS FLOAT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "nvl#13de9ce1fe22/ansi_on",
       "reason": "SELECT nvl(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -32,86 +8,6 @@
       "id": "nvl#13de9ce1fe22/ansi_off",
       "reason": "SELECT nvl(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "nvl#18036545751d/ansi_on",
-      "reason": "SELECT nvl(CAST(1.5 AS DECIMAL(38,18)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#18036545751d/ansi_off",
-      "reason": "SELECT nvl(CAST(1.5 AS DECIMAL(38,18)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#1cf818db1216/ansi_on",
-      "reason": "SELECT nvl(X'01', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#1cf818db1216/ansi_off",
-      "reason": "SELECT nvl(X'01', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#207e88f971e0/ansi_on",
-      "reason": "SELECT nvl(true, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#207e88f971e0/ansi_off",
-      "reason": "SELECT nvl(true, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#2305f5ee469a/ansi_on",
-      "reason": "SELECT nvl(named_struct('a', 1, 'b', 'x'), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#2305f5ee469a/ansi_off",
-      "reason": "SELECT nvl(named_struct('a', 1, 'b', 'x'), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#30624b2144a9/ansi_on",
-      "reason": "SELECT nvl(CAST(1 AS SMALLINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#30624b2144a9/ansi_off",
-      "reason": "SELECT nvl(CAST(1 AS SMALLINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#57346bea4d30/ansi_on",
-      "reason": "SELECT nvl(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#57346bea4d30/ansi_off",
-      "reason": "SELECT nvl(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#707b2299b507/ansi_on",
-      "reason": "SELECT nvl(1, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#707b2299b507/ansi_off",
-      "reason": "SELECT nvl(1, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#7cea853582ec/ansi_on",
-      "reason": "SELECT nvl('1', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#7cea853582ec/ansi_off",
-      "reason": "SELECT nvl('1', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#880ab25c6d7a/ansi_on",
-      "reason": "SELECT nvl(NULL, CAST(array(NULL) AS array<string>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "nvl#880ab25c6d7a/ansi_off",
-      "reason": "SELECT nvl(NULL, CAST(array(NULL) AS array<string>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "nvl#90bda17a241c/ansi_on",
-      "reason": "SELECT nvl(1.5D, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#90bda17a241c/ansi_off",
-      "reason": "SELECT nvl(1.5D, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "nvl#9e1045de78bd/ansi_on",
       "reason": "SELECT nvl(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -120,30 +16,6 @@
       "id": "nvl#9e1045de78bd/ansi_off",
       "reason": "SELECT nvl(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "nvl#9efd37c3d6f2/ansi_on",
-      "reason": "SELECT nvl(1L, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#9efd37c3d6f2/ansi_off",
-      "reason": "SELECT nvl(1L, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#a1c66c5ed996/ansi_on",
-      "reason": "SELECT nvl(array(1, 2), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "nvl#a1c66c5ed996/ansi_off",
-      "reason": "SELECT nvl(array(1, 2), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "nvl#a81f8052130a/ansi_on",
-      "reason": "SELECT nvl('abc', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#a81f8052130a/ansi_off",
-      "reason": "SELECT nvl('abc', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "nvl#b47cc5fd236f/ansi_on",
       "reason": "SELECT nvl(INTERVAL '1 02:03:04' DAY TO SECOND, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -152,30 +24,6 @@
       "id": "nvl#b47cc5fd236f/ansi_off",
       "reason": "SELECT nvl(INTERVAL '1 02:03:04' DAY TO SECOND, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "nvl#bcd71d6d3a0f/ansi_on",
-      "reason": "SELECT nvl(CAST(1 AS TINYINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#bcd71d6d3a0f/ansi_off",
-      "reason": "SELECT nvl(CAST(1 AS TINYINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#c72f6b63d89a/ansi_on",
-      "reason": "SELECT nvl(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#c72f6b63d89a/ansi_off",
-      "reason": "SELECT nvl(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#d2c5155ff20e/ansi_on",
-      "reason": "SELECT nvl(DATE'2024-02-29', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#d2c5155ff20e/ansi_off",
-      "reason": "SELECT nvl(DATE'2024-02-29', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "nvl#d806a1029577/ansi_on",
       "reason": "SELECT nvl(NULL, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -184,14 +32,6 @@
       "id": "nvl#d806a1029577/ansi_off",
       "reason": "SELECT nvl(NULL, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "nvl#db213cc5bb1d/ansi_on",
-      "reason": "SELECT nvl(CAST(1.5 AS DECIMAL(10,2)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl#db213cc5bb1d/ansi_off",
-      "reason": "SELECT nvl(CAST(1.5 AS DECIMAL(10,2)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "nvl#e0e8f9112791/ansi_on",
       "reason": "SELECT nvl(INTERVAL '1-2' YEAR TO MONTH, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -200,14 +40,6 @@
       "id": "nvl#e0e8f9112791/ansi_off",
       "reason": "SELECT nvl(INTERVAL '1-2' YEAR TO MONTH, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "nvl#f89a839e7d85/ansi_on",
-      "reason": "SELECT nvl(NULL, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "nvl#f89a839e7d85/ansi_off",
-      "reason": "SELECT nvl(NULL, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "nvl#fd2b816559e6/ansi_on",
       "reason": "SELECT nvl(NULL, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map"
diff --git a/tests/fixtures/analysis/registry-matrix/nvl2.json b/tests/fixtures/analysis/registry-matrix/nvl2.json
index a9af08eff..2c19d17c9 100644
--- a/tests/fixtures/analysis/registry-matrix/nvl2.json
+++ b/tests/fixtures/analysis/registry-matrix/nvl2.json
@@ -16,22 +16,6 @@
       "id": "nvl2#239048a3bfae/ansi_off",
       "reason": "SELECT nvl2(INTERVAL '1-2' YEAR TO MONTH, 2, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "nvl2#4e8e95ac7957/ansi_on",
-      "reason": "SELECT nvl2(NULL, 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl2#4e8e95ac7957/ansi_off",
-      "reason": "SELECT nvl2(NULL, 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl2#5ba4dfd6249b/ansi_on",
-      "reason": "SELECT nvl2(array(1, 2), 2, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "nvl2#5ba4dfd6249b/ansi_off",
-      "reason": "SELECT nvl2(array(1, 2), 2, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "nvl2#92c35e6b7596/ansi_on",
       "reason": "SELECT nvl2(NULL, map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -80,14 +64,6 @@
       "id": "nvl2#d68aaefed581/ansi_off",
       "reason": "SELECT nvl2(NULL, INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "nvl2#d91ae78c6447/ansi_on",
-      "reason": "SELECT nvl2(NULL, array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl2#d91ae78c6447/ansi_off",
-      "reason": "SELECT nvl2(NULL, array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "nvl2#e7ae2541b711/ansi_on",
       "reason": "SELECT nvl2(NULL, INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
diff --git a/tests/fixtures/analysis/registry-matrix/octet_length.json b/tests/fixtures/analysis/registry-matrix/octet_length.json
index 9dc2dee94..32b49f94c 100644
--- a/tests/fixtures/analysis/registry-matrix/octet_length.json
+++ b/tests/fixtures/analysis/registry-matrix/octet_length.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "octet_length#2796653aa88a/ansi_on",
-      "reason": "SELECT octet_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "octet_length#2796653aa88a/ansi_off",
-      "reason": "SELECT octet_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "octet_length#4a19477b96a3/ansi_on",
       "reason": "SELECT octet_length(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/parse_url.json b/tests/fixtures/analysis/registry-matrix/parse_url.json
index e9b496a4e..5978ffbd6 100644
--- a/tests/fixtures/analysis/registry-matrix/parse_url.json
+++ b/tests/fixtures/analysis/registry-matrix/parse_url.json
@@ -1,21 +1,5 @@
 {
   "entries": [
-    {
-      "id": "parse_url#160d5dee022a/ansi_on",
-      "reason": "SELECT parse_url(array(1, 2), 'HOST') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "parse_url#160d5dee022a/ansi_off",
-      "reason": "SELECT parse_url(array(1, 2), 'HOST') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "parse_url#4a439e17a195/ansi_on",
-      "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "parse_url#4a439e17a195/ansi_off",
-      "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "parse_url#5f1eb9069808/ansi_on",
       "reason": "SELECT parse_url(INTERVAL '1 02:03:04' DAY TO SECOND, 'QUERY', 'query') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,14 +24,6 @@
       "id": "parse_url#6a6783c67e72/ansi_off",
       "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "parse_url#77d4a881cf2e/ansi_on",
-      "reason": "SELECT parse_url(array(1, 2), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "parse_url#77d4a881cf2e/ansi_off",
-      "reason": "SELECT parse_url(array(1, 2), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "parse_url#7e07c0898f86/ansi_on",
       "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -56,14 +32,6 @@
       "id": "parse_url#7e07c0898f86/ansi_off",
       "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "parse_url#7f164b6a4717/ansi_on",
-      "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', array(1, 2), 'query') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "parse_url#7f164b6a4717/ansi_off",
-      "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', array(1, 2), 'query') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "parse_url#81533c28fb16/ansi_on",
       "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -96,14 +64,6 @@
       "id": "parse_url#915fd327d17a/ansi_off",
       "reason": "SELECT parse_url(INTERVAL '1-2' YEAR TO MONTH, 'HOST') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "parse_url#c8c89c406fbd/ansi_on",
-      "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "parse_url#c8c89c406fbd/ansi_off",
-      "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "parse_url#c943054aa066/ansi_on",
       "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/pmod.json b/tests/fixtures/analysis/registry-matrix/pmod.json
index 9f84e1c7e..2ee984598 100644
--- a/tests/fixtures/analysis/registry-matrix/pmod.json
+++ b/tests/fixtures/analysis/registry-matrix/pmod.json
@@ -4,14 +4,6 @@
       "id": "pmod#12b81d80212f/ansi_off",
       "reason": "SELECT pmod('1', 3) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "pmod#1a3001bfb1af/ansi_on",
-      "reason": "SELECT pmod(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "pmod#1a3001bfb1af/ansi_off",
-      "reason": "SELECT pmod(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "pmod#37a1b2aa82bb/ansi_on",
       "reason": "SELECT pmod(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -20,14 +12,6 @@
       "id": "pmod#37a1b2aa82bb/ansi_off",
       "reason": "SELECT pmod(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "pmod#45933ab5e0c9/ansi_on",
-      "reason": "SELECT pmod(10, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "pmod#45933ab5e0c9/ansi_off",
-      "reason": "SELECT pmod(10, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "pmod#4b50b5dc070f/ansi_off",
       "reason": "SELECT pmod('abc', 3) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
diff --git a/tests/fixtures/analysis/registry-matrix/position.json b/tests/fixtures/analysis/registry-matrix/position.json
index dbe805308..47a849dba 100644
--- a/tests/fixtures/analysis/registry-matrix/position.json
+++ b/tests/fixtures/analysis/registry-matrix/position.json
@@ -8,38 +8,6 @@
       "id": "position#09c5e86aaead/ansi_off",
       "reason": "SELECT position('bar', 'foobarbar', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "position#26704394f4cf/ansi_on",
-      "reason": "SELECT position('bar', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "position#26704394f4cf/ansi_off",
-      "reason": "SELECT position('bar', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "position#293624608222/ansi_on",
-      "reason": "SELECT position(array(1, 2), 'foobarbar', 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "position#293624608222/ansi_off",
-      "reason": "SELECT position(array(1, 2), 'foobarbar', 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "position#356d859fa414/ansi_on",
-      "reason": "SELECT position('bar', array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "position#356d859fa414/ansi_off",
-      "reason": "SELECT position('bar', array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "position#35a7a4e8d0fc/ansi_on",
-      "reason": "SELECT position(array(1, 2), 'foobarbar') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "position#35a7a4e8d0fc/ansi_off",
-      "reason": "SELECT position(array(1, 2), 'foobarbar') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "position#401cb85e8a92/ansi_on",
       "reason": "SELECT position('bar', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -112,14 +80,6 @@
       "id": "position#a474bf49e08d/ansi_off",
       "reason": "SELECT position(INTERVAL '1-2' YEAR TO MONTH, 'foobarbar', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "position#b68c8f623388/ansi_on",
-      "reason": "SELECT position('bar', 'foobarbar', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "position#b68c8f623388/ansi_off",
-      "reason": "SELECT position('bar', 'foobarbar', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "position#bf25e422a3c1/ansi_on",
       "reason": "SELECT position('bar', INTERVAL '1 02:03:04' DAY TO SECOND, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/positive.json b/tests/fixtures/analysis/registry-matrix/positive.json
index 65d4b214b..bbc91b097 100644
--- a/tests/fixtures/analysis/registry-matrix/positive.json
+++ b/tests/fixtures/analysis/registry-matrix/positive.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "positive#2925bd78f863/ansi_on",
-      "reason": "SELECT positive(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "positive#2925bd78f863/ansi_off",
-      "reason": "SELECT positive(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "positive#66e665f762a8/ansi_on",
       "reason": "SELECT positive(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/pow.json b/tests/fixtures/analysis/registry-matrix/pow.json
index 3724f1036..d6a7ab9b0 100644
--- a/tests/fixtures/analysis/registry-matrix/pow.json
+++ b/tests/fixtures/analysis/registry-matrix/pow.json
@@ -47,22 +47,6 @@
     {
       "id": "pow#a5c5256f4fbf/ansi_off",
       "reason": "SELECT pow(2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "pow#e67e8e6f1e7e/ansi_on",
-      "reason": "SELECT pow(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "pow#e67e8e6f1e7e/ansi_off",
-      "reason": "SELECT pow(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "pow#f94cefe76fff/ansi_on",
-      "reason": "SELECT pow(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "pow#f94cefe76fff/ansi_off",
-      "reason": "SELECT pow(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/power.json b/tests/fixtures/analysis/registry-matrix/power.json
index ec7847742..b544a575c 100644
--- a/tests/fixtures/analysis/registry-matrix/power.json
+++ b/tests/fixtures/analysis/registry-matrix/power.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "power#1fb3cb5e732f/ansi_on",
-      "reason": "SELECT power(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "power#1fb3cb5e732f/ansi_off",
-      "reason": "SELECT power(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "power#50aa498e03a3/ansi_on",
       "reason": "SELECT power(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -32,14 +24,6 @@
       "id": "power#58436b99c0b7/ansi_off",
       "reason": "SELECT power(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "power#768810ae773a/ansi_on",
-      "reason": "SELECT power(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "power#768810ae773a/ansi_off",
-      "reason": "SELECT power(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "power#a72d919ec412/ansi_on",
       "reason": "SELECT power(2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/quarter.json b/tests/fixtures/analysis/registry-matrix/quarter.json
index 39d7b5a21..f006e81b0 100644
--- a/tests/fixtures/analysis/registry-matrix/quarter.json
+++ b/tests/fixtures/analysis/registry-matrix/quarter.json
@@ -23,14 +23,6 @@
     {
       "id": "quarter#7e5e4bb0baa2/ansi_off",
       "reason": "SELECT quarter(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "quarter#9e53c8e4594f/ansi_on",
-      "reason": "SELECT quarter(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "quarter#9e53c8e4594f/ansi_off",
-      "reason": "SELECT quarter(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/quote.json b/tests/fixtures/analysis/registry-matrix/quote.json
index c92ee7aec..86d116461 100644
--- a/tests/fixtures/analysis/registry-matrix/quote.json
+++ b/tests/fixtures/analysis/registry-matrix/quote.json
@@ -16,14 +16,6 @@
       "id": "quote#45b899b5afde/ansi_off",
       "reason": "SELECT quote(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "quote#58f2ef4a2339/ansi_on",
-      "reason": "SELECT quote(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "quote#58f2ef4a2339/ansi_off",
-      "reason": "SELECT quote(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "quote#e072b999e0ab/ansi_on",
       "reason": "SELECT quote(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/radians.json b/tests/fixtures/analysis/registry-matrix/radians.json
index 2a0bbf380..cadb278fd 100644
--- a/tests/fixtures/analysis/registry-matrix/radians.json
+++ b/tests/fixtures/analysis/registry-matrix/radians.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "radians#595d7d8afe29/ansi_on",
-      "reason": "SELECT radians(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "radians#595d7d8afe29/ansi_off",
-      "reason": "SELECT radians(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "radians#a6b560943a35/ansi_on",
       "reason": "SELECT radians(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/raise_error.json b/tests/fixtures/analysis/registry-matrix/raise_error.json
index 23d69cbd1..e790d810e 100644
--- a/tests/fixtures/analysis/registry-matrix/raise_error.json
+++ b/tests/fixtures/analysis/registry-matrix/raise_error.json
@@ -16,14 +16,6 @@
       "id": "raise_error#30a64ebeeb6a/ansi_off",
       "reason": "SELECT raise_error(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "raise_error#5d4434d2c075/ansi_on",
-      "reason": "SELECT raise_error(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "raise_error#5d4434d2c075/ansi_off",
-      "reason": "SELECT raise_error(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "raise_error#7316fcbbf706/ansi_on",
       "reason": "SELECT raise_error(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/rand.json b/tests/fixtures/analysis/registry-matrix/rand.json
index c92cc4430..610f5ddb6 100644
--- a/tests/fixtures/analysis/registry-matrix/rand.json
+++ b/tests/fixtures/analysis/registry-matrix/rand.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "rand#114bc082913c/ansi_on",
-      "reason": "SELECT rand(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rand#114bc082913c/ansi_off",
-      "reason": "SELECT rand(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rand#16b39c8effd3/ansi_on",
       "reason": "SELECT rand(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/randn.json b/tests/fixtures/analysis/registry-matrix/randn.json
index d01eca515..5fcb326f1 100644
--- a/tests/fixtures/analysis/registry-matrix/randn.json
+++ b/tests/fixtures/analysis/registry-matrix/randn.json
@@ -23,14 +23,6 @@
     {
       "id": "randn#9df340e4c4ed/ansi_off",
       "reason": "SELECT randn(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "randn#db9474536e6f/ansi_on",
-      "reason": "SELECT randn(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "randn#db9474536e6f/ansi_off",
-      "reason": "SELECT randn(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/random.json b/tests/fixtures/analysis/registry-matrix/random.json
index 83f5dfa94..dab9bc0cd 100644
--- a/tests/fixtures/analysis/registry-matrix/random.json
+++ b/tests/fixtures/analysis/registry-matrix/random.json
@@ -16,14 +16,6 @@
       "id": "random#73bb8aca50b7/ansi_off",
       "reason": "SELECT random(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "random#aafd575271fd/ansi_on",
-      "reason": "SELECT random(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "random#aafd575271fd/ansi_off",
-      "reason": "SELECT random(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "random#b218d468723d/ansi_on",
       "reason": "SELECT random(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/randstr.json b/tests/fixtures/analysis/registry-matrix/randstr.json
index c38e1ca9d..81e46a666 100644
--- a/tests/fixtures/analysis/registry-matrix/randstr.json
+++ b/tests/fixtures/analysis/registry-matrix/randstr.json
@@ -16,22 +16,6 @@
       "id": "randstr#55df7b2e1334/ansi_off",
       "reason": "SELECT randstr(3, INTERVAL '1 02:03:04' DAY TO SECOND) AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "randstr#72a2793557e6/ansi_on",
-      "reason": "SELECT randstr(array(1, 2), 0) AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "randstr#72a2793557e6/ansi_off",
-      "reason": "SELECT randstr(array(1, 2), 0) AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "randstr#78a2b0d4ee1a/ansi_on",
-      "reason": "SELECT randstr(3, array(1, 2)) AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "randstr#78a2b0d4ee1a/ansi_off",
-      "reason": "SELECT randstr(3, array(1, 2)) AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "randstr#9e4c25337d0d/ansi_on",
       "reason": "SELECT randstr(map('a', 1), 0) AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/regexp.json b/tests/fixtures/analysis/registry-matrix/regexp.json
index b97dc5200..db18900bc 100644
--- a/tests/fixtures/analysis/registry-matrix/regexp.json
+++ b/tests/fixtures/analysis/registry-matrix/regexp.json
@@ -40,22 +40,6 @@
       "id": "regexp#7a9373d75338/ansi_off",
       "reason": "SELECT regexp('%SystemDrive%\\Users\\John', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp#7e85a4423a0c/ansi_on",
-      "reason": "SELECT regexp(array(1, 2), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp#7e85a4423a0c/ansi_off",
-      "reason": "SELECT regexp(array(1, 2), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp#b5e72f23ba3a/ansi_on",
-      "reason": "SELECT regexp('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp#b5e72f23ba3a/ansi_off",
-      "reason": "SELECT regexp('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "regexp#f2d787a50f4c/ansi_on",
       "reason": "SELECT regexp(map('a', 1), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/regexp_count.json b/tests/fixtures/analysis/registry-matrix/regexp_count.json
index 2d1df1bda..2fd277e3d 100644
--- a/tests/fixtures/analysis/registry-matrix/regexp_count.json
+++ b/tests/fixtures/analysis/registry-matrix/regexp_count.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "regexp_count#07bc658c7105/ansi_on",
-      "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_count#07bc658c7105/ansi_off",
-      "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "regexp_count#0afc8da34f72/ansi_on",
       "reason": "SELECT regexp_count(map('a', 1), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -48,14 +40,6 @@
       "id": "regexp_count#4e5127786dc5/ansi_off",
       "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "regexp_count#cdb52bc0b466/ansi_on",
-      "reason": "SELECT regexp_count(array(1, 2), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_count#cdb52bc0b466/ansi_off",
-      "reason": "SELECT regexp_count(array(1, 2), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "regexp_count#e50fca3b8f7b/ansi_on",
       "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/regexp_extract.json b/tests/fixtures/analysis/registry-matrix/regexp_extract.json
index cc55db568..2074f6b7f 100644
--- a/tests/fixtures/analysis/registry-matrix/regexp_extract.json
+++ b/tests/fixtures/analysis/registry-matrix/regexp_extract.json
@@ -40,22 +40,6 @@
       "id": "regexp_extract#41eb55972574/ansi_off",
       "reason": "SELECT regexp_extract('100-200', INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "regexp_extract#41ef0cdd8f83/ansi_on",
-      "reason": "SELECT regexp_extract('100-200', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_extract#41ef0cdd8f83/ansi_off",
-      "reason": "SELECT regexp_extract('100-200', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_extract#74bd57081b89/ansi_on",
-      "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_extract#74bd57081b89/ansi_off",
-      "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "regexp_extract#8abf01d909ed/ansi_on",
       "reason": "SELECT regexp_extract(INTERVAL '1-2' YEAR TO MONTH, '(\\\\d+)-(\\\\d+)', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -87,14 +71,6 @@
     {
       "id": "regexp_extract#e4b7e0aa5c1b/ansi_off",
       "reason": "SELECT regexp_extract(map('a', 1), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_extract#fdd1523dc79a/ansi_on",
-      "reason": "SELECT regexp_extract(array(1, 2), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_extract#fdd1523dc79a/ansi_off",
-      "reason": "SELECT regexp_extract(array(1, 2), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/regexp_instr.json b/tests/fixtures/analysis/registry-matrix/regexp_instr.json
index 04dfa7225..5cd72aae7 100644
--- a/tests/fixtures/analysis/registry-matrix/regexp_instr.json
+++ b/tests/fixtures/analysis/registry-matrix/regexp_instr.json
@@ -40,14 +40,6 @@
       "id": "regexp_instr#a177fdc18858/ansi_off",
       "reason": "SELECT regexp_instr(map('a', 1), r\"^\\\\abc$\") | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_instr#d1b7ae971b09/ansi_on",
-      "reason": "SELECT regexp_instr(r\"\\abc\", array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_instr#d1b7ae971b09/ansi_off",
-      "reason": "SELECT regexp_instr(r\"\\abc\", array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "regexp_instr#e495063cde68/ansi_on",
       "reason": "SELECT regexp_instr(r\"\\abc\", INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -55,14 +47,6 @@
     {
       "id": "regexp_instr#e495063cde68/ansi_off",
       "reason": "SELECT regexp_instr(r\"\\abc\", INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "regexp_instr#eb546ff0ffa5/ansi_on",
-      "reason": "SELECT regexp_instr(array(1, 2), r\"^\\\\abc$\") | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_instr#eb546ff0ffa5/ansi_off",
-      "reason": "SELECT regexp_instr(array(1, 2), r\"^\\\\abc$\") | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/regexp_like.json b/tests/fixtures/analysis/registry-matrix/regexp_like.json
index 1e2f828a1..75073ddfd 100644
--- a/tests/fixtures/analysis/registry-matrix/regexp_like.json
+++ b/tests/fixtures/analysis/registry-matrix/regexp_like.json
@@ -24,14 +24,6 @@
       "id": "regexp_like#84a661eb1231/ansi_off",
       "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_like#890c550d2cad/ansi_on",
-      "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_like#890c550d2cad/ansi_off",
-      "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "regexp_like#8ed857c04e18/ansi_on",
       "reason": "SELECT regexp_like(map('a', 1), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -55,14 +47,6 @@
     {
       "id": "regexp_like#e155c6f9762d/ansi_off",
       "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "regexp_like#f002c215b8c3/ansi_on",
-      "reason": "SELECT regexp_like(array(1, 2), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_like#f002c215b8c3/ansi_off",
-      "reason": "SELECT regexp_like(array(1, 2), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/regexp_replace.json b/tests/fixtures/analysis/registry-matrix/regexp_replace.json
index 4cc30aedb..6faf1c92d 100644
--- a/tests/fixtures/analysis/registry-matrix/regexp_replace.json
+++ b/tests/fixtures/analysis/registry-matrix/regexp_replace.json
@@ -48,22 +48,6 @@
       "id": "regexp_replace#4554f98913c4/ansi_off",
       "reason": "SELECT regexp_replace('100-200', map('a', 1), 'num') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_replace#4e808b6ab3ea/ansi_on",
-      "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_replace#4e808b6ab3ea/ansi_off",
-      "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_replace#790472f65a6c/ansi_on",
-      "reason": "SELECT regexp_replace('100-200', array(1, 2), 'num') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_replace#790472f65a6c/ansi_off",
-      "reason": "SELECT regexp_replace('100-200', array(1, 2), 'num') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "regexp_replace#d6194fc8a763/ansi_on",
       "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -87,14 +71,6 @@
     {
       "id": "regexp_replace#fb02919091af/ansi_off",
       "reason": "SELECT regexp_replace(INTERVAL '1-2' YEAR TO MONTH, '(\\\\d+)', 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "regexp_replace#fb71844662a3/ansi_on",
-      "reason": "SELECT regexp_replace(array(1, 2), '(\\\\d+)', 'num') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_replace#fb71844662a3/ansi_off",
-      "reason": "SELECT regexp_replace(array(1, 2), '(\\\\d+)', 'num') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/regexp_substr.json b/tests/fixtures/analysis/registry-matrix/regexp_substr.json
index 0047d43c1..814508cfd 100644
--- a/tests/fixtures/analysis/registry-matrix/regexp_substr.json
+++ b/tests/fixtures/analysis/registry-matrix/regexp_substr.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "regexp_substr#057311aea945/ansi_on",
-      "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_substr#057311aea945/ansi_off",
-      "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "regexp_substr#5cb59df0f0ef/ansi_on",
       "reason": "SELECT regexp_substr(INTERVAL '1-2' YEAR TO MONTH, 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -40,14 +32,6 @@
       "id": "regexp_substr#892ffdc712e7/ansi_off",
       "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "regexp_substr#97d5b3fe669b/ansi_on",
-      "reason": "SELECT regexp_substr(array(1, 2), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_substr#97d5b3fe669b/ansi_off",
-      "reason": "SELECT regexp_substr(array(1, 2), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "regexp_substr#cc9e77840c0c/ansi_on",
       "reason": "SELECT regexp_substr(map('a', 1), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/repeat.json b/tests/fixtures/analysis/registry-matrix/repeat.json
index 3792065f4..64136c126 100644
--- a/tests/fixtures/analysis/registry-matrix/repeat.json
+++ b/tests/fixtures/analysis/registry-matrix/repeat.json
@@ -40,22 +40,6 @@
       "id": "repeat#bb2d12b4940f/ansi_off",
       "reason": "SELECT repeat('123', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "repeat#bc6f7f572b92/ansi_on",
-      "reason": "SELECT repeat(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "repeat#bc6f7f572b92/ansi_off",
-      "reason": "SELECT repeat(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "repeat#e5c70b9a419f/ansi_on",
-      "reason": "SELECT repeat('123', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "repeat#e5c70b9a419f/ansi_off",
-      "reason": "SELECT repeat('123', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "repeat#f3373137eed5/ansi_on",
       "reason": "SELECT repeat('123', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/replace.json b/tests/fixtures/analysis/registry-matrix/replace.json
index f95462ca3..fa5eff5de 100644
--- a/tests/fixtures/analysis/registry-matrix/replace.json
+++ b/tests/fixtures/analysis/registry-matrix/replace.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "replace#45892c6e41c2/ansi_on",
-      "reason": "SELECT replace('ABCabc', array(1, 2), 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "replace#45892c6e41c2/ansi_off",
-      "reason": "SELECT replace('ABCabc', array(1, 2), 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "replace#5c277e88fd2d/ansi_on",
       "reason": "SELECT replace('ABCabc', 'abc', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -24,14 +16,6 @@
       "id": "replace#773d4608b460/ansi_off",
       "reason": "SELECT replace('ABCabc', 'abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "replace#7994c08a31a3/ansi_on",
-      "reason": "SELECT replace(array(1, 2), 'abc', 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "replace#7994c08a31a3/ansi_off",
-      "reason": "SELECT replace(array(1, 2), 'abc', 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "replace#8abe9653048f/ansi_on",
       "reason": "SELECT replace('ABCabc', INTERVAL '1 02:03:04' DAY TO SECOND, 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -64,14 +48,6 @@
       "id": "replace#bc3da4b48ee0/ansi_off",
       "reason": "SELECT replace(INTERVAL '1 02:03:04' DAY TO SECOND, 'abc', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "replace#bf27e8ab957c/ansi_on",
-      "reason": "SELECT replace('ABCabc', 'abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "replace#bf27e8ab957c/ansi_off",
-      "reason": "SELECT replace('ABCabc', 'abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "replace#d9f91490acc7/ansi_on",
       "reason": "SELECT replace('ABCabc', map('a', 1), 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/reverse.json b/tests/fixtures/analysis/registry-matrix/reverse.json
index 7f3e6d881..c2a3e663d 100644
--- a/tests/fixtures/analysis/registry-matrix/reverse.json
+++ b/tests/fixtures/analysis/registry-matrix/reverse.json
@@ -2,27 +2,27 @@
   "entries": [
     {
       "id": "reverse#1eeb8d128702/ansi_on",
-      "reason": "SELECT reverse(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT reverse(array(1, 2)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "reverse#1eeb8d128702/ansi_off",
-      "reason": "SELECT reverse(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT reverse(array(1, 2)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "reverse#27d73e6b9b7a/ansi_on",
-      "reason": "SELECT reverse(CAST(array(NULL) AS array<int>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT reverse(CAST(array(NULL) AS array<int>)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "reverse#27d73e6b9b7a/ansi_off",
-      "reason": "SELECT reverse(CAST(array(NULL) AS array<int>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT reverse(CAST(array(NULL) AS array<int>)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "reverse#58b4d7850388/ansi_on",
-      "reason": "SELECT reverse(array(2, 1, 4, 3)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT reverse(array(2, 1, 4, 3)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "reverse#58b4d7850388/ansi_off",
-      "reason": "SELECT reverse(array(2, 1, 4, 3)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT reverse(array(2, 1, 4, 3)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "reverse#61dbbe3b92fa/ansi_on",
@@ -34,11 +34,11 @@
     },
     {
       "id": "reverse#6d11d9d7634a/ansi_on",
-      "reason": "SELECT reverse(CAST(array() AS array<int>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT reverse(CAST(array() AS array<int>)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "reverse#6d11d9d7634a/ansi_off",
-      "reason": "SELECT reverse(CAST(array() AS array<int>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT reverse(CAST(array() AS array<int>)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "reverse#b32c7db50969/ansi_on",
diff --git a/tests/fixtures/analysis/registry-matrix/right.json b/tests/fixtures/analysis/registry-matrix/right.json
index 3d5a493ff..7a7bdba84 100644
--- a/tests/fixtures/analysis/registry-matrix/right.json
+++ b/tests/fixtures/analysis/registry-matrix/right.json
@@ -40,22 +40,6 @@
       "id": "right#a05d0302bdb5/ansi_off",
       "reason": "SELECT right('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "right#c9d2d8acae93/ansi_on",
-      "reason": "SELECT right('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "right#c9d2d8acae93/ansi_off",
-      "reason": "SELECT right('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "right#e88efa96dc77/ansi_on",
-      "reason": "SELECT right(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "right#e88efa96dc77/ansi_off",
-      "reason": "SELECT right(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "right#f10f3e53b1e8/ansi_on",
       "reason": "SELECT right(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/rint.json b/tests/fixtures/analysis/registry-matrix/rint.json
index 6a6d25172..15b909b93 100644
--- a/tests/fixtures/analysis/registry-matrix/rint.json
+++ b/tests/fixtures/analysis/registry-matrix/rint.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "rint#7531928e97b1/ansi_on",
-      "reason": "SELECT rint(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rint#7531928e97b1/ansi_off",
-      "reason": "SELECT rint(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rint#baeea376e1af/ansi_on",
       "reason": "SELECT rint(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/round.json b/tests/fixtures/analysis/registry-matrix/round.json
index 136610fab..472882bef 100644
--- a/tests/fixtures/analysis/registry-matrix/round.json
+++ b/tests/fixtures/analysis/registry-matrix/round.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "round#1e8de844e85f/ansi_on",
-      "reason": "SELECT round(2.5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "round#1e8de844e85f/ansi_off",
-      "reason": "SELECT round(2.5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "round#286ac35a7044/ansi_on",
       "reason": "SELECT round(2.5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -55,14 +47,6 @@
     {
       "id": "round#efef4a884ef2/ansi_off",
       "reason": "SELECT round(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "round#f890b98f5266/ansi_on",
-      "reason": "SELECT round(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "round#f890b98f5266/ansi_off",
-      "reason": "SELECT round(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/rpad.json b/tests/fixtures/analysis/registry-matrix/rpad.json
index 1651b16f4..18f2a3740 100644
--- a/tests/fixtures/analysis/registry-matrix/rpad.json
+++ b/tests/fixtures/analysis/registry-matrix/rpad.json
@@ -8,14 +8,6 @@
       "id": "rpad#01185a535503/ansi_off",
       "reason": "SELECT rpad('hi', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "rpad#06a27aefc3e8/ansi_on",
-      "reason": "SELECT rpad('hi', array(1, 2), '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rpad#06a27aefc3e8/ansi_off",
-      "reason": "SELECT rpad('hi', array(1, 2), '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rpad#0bf1aa70ff76/ansi_on",
       "reason": "SELECT rpad('hi', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -48,22 +40,6 @@
       "id": "rpad#2df795636485/ansi_off",
       "reason": "SELECT rpad('hi', 5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "rpad#34af1695c2fb/ansi_on",
-      "reason": "SELECT rpad(array(1, 2), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rpad#34af1695c2fb/ansi_off",
-      "reason": "SELECT rpad(array(1, 2), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rpad#4b9f09ad06a5/ansi_on",
-      "reason": "SELECT rpad('hi', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rpad#4b9f09ad06a5/ansi_off",
-      "reason": "SELECT rpad('hi', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rpad#7acc254d2875/ansi_on",
       "reason": "SELECT rpad(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -120,14 +96,6 @@
       "id": "rpad#c2dc63c23dd1/ansi_off",
       "reason": "SELECT rpad('hi', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "rpad#c36fcf5d02d6/ansi_on",
-      "reason": "SELECT rpad(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rpad#c36fcf5d02d6/ansi_off",
-      "reason": "SELECT rpad(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rpad#d8ee019cf6cd/ansi_on",
       "reason": "SELECT rpad('hi', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -136,14 +104,6 @@
       "id": "rpad#d8ee019cf6cd/ansi_off",
       "reason": "SELECT rpad('hi', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "rpad#e70e9a4e3801/ansi_on",
-      "reason": "SELECT rpad('hi', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rpad#e70e9a4e3801/ansi_off",
-      "reason": "SELECT rpad('hi', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rpad#f3cf473e2510/ansi_on",
       "reason": "SELECT rpad(map('a', 1), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/rtrim.json b/tests/fixtures/analysis/registry-matrix/rtrim.json
index da3d2dc52..33ae10d7f 100644
--- a/tests/fixtures/analysis/registry-matrix/rtrim.json
+++ b/tests/fixtures/analysis/registry-matrix/rtrim.json
@@ -8,14 +8,6 @@
       "id": "rtrim#1737a0f2a2dc/ansi_off",
       "reason": "SELECT rtrim(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "rtrim#414ec50a8836/ansi_on",
-      "reason": "SELECT rtrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rtrim#414ec50a8836/ansi_off",
-      "reason": "SELECT rtrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rtrim#4f1bf1caadb5/ansi_on",
       "reason": "SELECT rtrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/schema_of_csv.json b/tests/fixtures/analysis/registry-matrix/schema_of_csv.json
index 6a27c7925..aeeea7275 100644
--- a/tests/fixtures/analysis/registry-matrix/schema_of_csv.json
+++ b/tests/fixtures/analysis/registry-matrix/schema_of_csv.json
@@ -34,11 +34,11 @@
     },
     {
       "id": "schema_of_csv#8df93023554a/ansi_on",
-      "reason": "SELECT schema_of_csv(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT schema_of_csv(array(1, 2)) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "schema_of_csv#8df93023554a/ansi_off",
-      "reason": "SELECT schema_of_csv(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT schema_of_csv(array(1, 2)) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "schema_of_csv#c528f58d61a7/ansi_on",
diff --git a/tests/fixtures/analysis/registry-matrix/sec.json b/tests/fixtures/analysis/registry-matrix/sec.json
index 8d0474fec..91ccb91be 100644
--- a/tests/fixtures/analysis/registry-matrix/sec.json
+++ b/tests/fixtures/analysis/registry-matrix/sec.json
@@ -23,14 +23,6 @@
     {
       "id": "sec#c2e9bb28ade3/ansi_off",
       "reason": "SELECT sec(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sec#faa27900f220/ansi_on",
-      "reason": "SELECT sec(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sec#faa27900f220/ansi_off",
-      "reason": "SELECT sec(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/second.json b/tests/fixtures/analysis/registry-matrix/second.json
index 07f6e1f92..d312cf523 100644
--- a/tests/fixtures/analysis/registry-matrix/second.json
+++ b/tests/fixtures/analysis/registry-matrix/second.json
@@ -32,14 +32,6 @@
       "id": "second#ade2ed5d7b44/ansi_off",
       "reason": "SELECT second(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "second#b6eb034a6cc6/ansi_on",
-      "reason": "SELECT second(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "second#b6eb034a6cc6/ansi_off",
-      "reason": "SELECT second(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "second#edf06afe63c6/ansi_on",
       "reason": "SELECT second(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/sha.json b/tests/fixtures/analysis/registry-matrix/sha.json
index 68a31db7c..f3428ec10 100644
--- a/tests/fixtures/analysis/registry-matrix/sha.json
+++ b/tests/fixtures/analysis/registry-matrix/sha.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "sha#2112efaa84c9/ansi_on",
-      "reason": "SELECT sha(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha#2112efaa84c9/ansi_off",
-      "reason": "SELECT sha(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sha#a6b6487665d4/ansi_on",
       "reason": "SELECT sha(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/sha1.json b/tests/fixtures/analysis/registry-matrix/sha1.json
index 6dd21ae0f..539e7afba 100644
--- a/tests/fixtures/analysis/registry-matrix/sha1.json
+++ b/tests/fixtures/analysis/registry-matrix/sha1.json
@@ -23,14 +23,6 @@
     {
       "id": "sha1#c4dfb65cb3b0/ansi_off",
       "reason": "SELECT sha1(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha1#c90b1625d341/ansi_on",
-      "reason": "SELECT sha1(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha1#c90b1625d341/ansi_off",
-      "reason": "SELECT sha1(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/sha2.json b/tests/fixtures/analysis/registry-matrix/sha2.json
index ee0dffc73..91165cbff 100644
--- a/tests/fixtures/analysis/registry-matrix/sha2.json
+++ b/tests/fixtures/analysis/registry-matrix/sha2.json
@@ -16,14 +16,6 @@
       "id": "sha2#0d551c2bd461/ansi_off",
       "reason": "SELECT sha2(map('a', 1), 256) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sha2#471a5e7d41fd/ansi_on",
-      "reason": "SELECT sha2(array(1, 2), 256) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha2#471a5e7d41fd/ansi_off",
-      "reason": "SELECT sha2(array(1, 2), 256) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sha2#5e52fda43a4c/ansi_on",
       "reason": "SELECT sha2('Spark', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -32,14 +24,6 @@
       "id": "sha2#5e52fda43a4c/ansi_off",
       "reason": "SELECT sha2('Spark', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sha2#9286f569ccc1/ansi_on",
-      "reason": "SELECT sha2('Spark', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha2#9286f569ccc1/ansi_off",
-      "reason": "SELECT sha2('Spark', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sha2#9a804177f733/ansi_on",
       "reason": "SELECT sha2('Spark', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/shiftleft.json b/tests/fixtures/analysis/registry-matrix/shiftleft.json
index 9667b3d82..9a48725b3 100644
--- a/tests/fixtures/analysis/registry-matrix/shiftleft.json
+++ b/tests/fixtures/analysis/registry-matrix/shiftleft.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "shiftleft#028e57cb3126/ansi_on",
-      "reason": "SELECT shiftleft(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "shiftleft#028e57cb3126/ansi_off",
-      "reason": "SELECT shiftleft(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "shiftleft#109b5e440103/ansi_on",
       "reason": "SELECT shiftleft(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -16,14 +8,6 @@
       "id": "shiftleft#109b5e440103/ansi_off",
       "reason": "SELECT shiftleft(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "shiftleft#43daf427dafa/ansi_on",
-      "reason": "SELECT shiftleft(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "shiftleft#43daf427dafa/ansi_off",
-      "reason": "SELECT shiftleft(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "shiftleft#75289f56a862/ansi_on",
       "reason": "SELECT shiftleft(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/shiftright.json b/tests/fixtures/analysis/registry-matrix/shiftright.json
index b783729c6..0c0e64459 100644
--- a/tests/fixtures/analysis/registry-matrix/shiftright.json
+++ b/tests/fixtures/analysis/registry-matrix/shiftright.json
@@ -8,14 +8,6 @@
       "id": "shiftright#0437ecb33db7/ansi_off",
       "reason": "SELECT shiftright(INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "shiftright#387cad49d8da/ansi_on",
-      "reason": "SELECT shiftright(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "shiftright#387cad49d8da/ansi_off",
-      "reason": "SELECT shiftright(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "shiftright#43df86d52cf4/ansi_on",
       "reason": "SELECT shiftright(4, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -48,14 +40,6 @@
       "id": "shiftright#9d0da0110d86/ansi_off",
       "reason": "SELECT shiftright(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "shiftright#a583285fa625/ansi_on",
-      "reason": "SELECT shiftright(4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "shiftright#a583285fa625/ansi_off",
-      "reason": "SELECT shiftright(4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "shiftright#b67e2d9bbada/ansi_on",
       "reason": "SELECT shiftright(4, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json b/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json
index 5c791ca34..cf7fbc34e 100644
--- a/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json
+++ b/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json
@@ -8,22 +8,6 @@
       "id": "shiftrightunsigned#5a87b30b960f/ansi_off",
       "reason": "SELECT shiftrightunsigned(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "shiftrightunsigned#5b6f5e1feb81/ansi_on",
-      "reason": "SELECT shiftrightunsigned(4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "shiftrightunsigned#5b6f5e1feb81/ansi_off",
-      "reason": "SELECT shiftrightunsigned(4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "shiftrightunsigned#9deada350e37/ansi_on",
-      "reason": "SELECT shiftrightunsigned(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "shiftrightunsigned#9deada350e37/ansi_off",
-      "reason": "SELECT shiftrightunsigned(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "shiftrightunsigned#a296dcfd561b/ansi_on",
       "reason": "SELECT shiftrightunsigned(INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/sign.json b/tests/fixtures/analysis/registry-matrix/sign.json
index acb8508dc..0722da7a0 100644
--- a/tests/fixtures/analysis/registry-matrix/sign.json
+++ b/tests/fixtures/analysis/registry-matrix/sign.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "sign#13016f33ae80/ansi_on",
-      "reason": "SELECT sign(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sign#13016f33ae80/ansi_off",
-      "reason": "SELECT sign(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sign#13e8c1b20b6e/ansi_on",
       "reason": "SELECT sign(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/signum.json b/tests/fixtures/analysis/registry-matrix/signum.json
index da57112d3..f92fdc005 100644
--- a/tests/fixtures/analysis/registry-matrix/signum.json
+++ b/tests/fixtures/analysis/registry-matrix/signum.json
@@ -8,14 +8,6 @@
       "id": "signum#1faf24081a60/ansi_off",
       "reason": "SELECT signum(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "signum#5de30314d52d/ansi_on",
-      "reason": "SELECT signum(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "signum#5de30314d52d/ansi_off",
-      "reason": "SELECT signum(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "signum#7c837d354941/ansi_on",
       "reason": "SELECT signum(INTERVAL -'100' YEAR) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/sin.json b/tests/fixtures/analysis/registry-matrix/sin.json
index 8a8b79ced..9b4e2b91a 100644
--- a/tests/fixtures/analysis/registry-matrix/sin.json
+++ b/tests/fixtures/analysis/registry-matrix/sin.json
@@ -8,14 +8,6 @@
       "id": "sin#07aad739ca7b/ansi_off",
       "reason": "SELECT sin(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sin#30ae963d3d6f/ansi_on",
-      "reason": "SELECT sin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sin#30ae963d3d6f/ansi_off",
-      "reason": "SELECT sin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sin#6de2eba5fd5b/ansi_on",
       "reason": "SELECT sin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/sinh.json b/tests/fixtures/analysis/registry-matrix/sinh.json
index 93463231c..2016e4a9b 100644
--- a/tests/fixtures/analysis/registry-matrix/sinh.json
+++ b/tests/fixtures/analysis/registry-matrix/sinh.json
@@ -16,14 +16,6 @@
       "id": "sinh#7f3e399ee823/ansi_off",
       "reason": "SELECT sinh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sinh#a4b246d8f999/ansi_on",
-      "reason": "SELECT sinh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sinh#a4b246d8f999/ansi_off",
-      "reason": "SELECT sinh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sinh#feb84311c281/ansi_on",
       "reason": "SELECT sinh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/soundex.json b/tests/fixtures/analysis/registry-matrix/soundex.json
index 1ff14203f..d8b2b551b 100644
--- a/tests/fixtures/analysis/registry-matrix/soundex.json
+++ b/tests/fixtures/analysis/registry-matrix/soundex.json
@@ -8,14 +8,6 @@
       "id": "soundex#7052e1ce9db0/ansi_off",
       "reason": "SELECT soundex(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "soundex#c9cba0075083/ansi_on",
-      "reason": "SELECT soundex(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "soundex#c9cba0075083/ansi_off",
-      "reason": "SELECT soundex(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "soundex#ccd858418689/ansi_on",
       "reason": "SELECT soundex(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/space.json b/tests/fixtures/analysis/registry-matrix/space.json
index 748b81a95..d92b8b340 100644
--- a/tests/fixtures/analysis/registry-matrix/space.json
+++ b/tests/fixtures/analysis/registry-matrix/space.json
@@ -23,14 +23,6 @@
     {
       "id": "space#e3f2323efc90/ansi_off",
       "reason": "SELECT concat(space(INTERVAL '1-2' YEAR TO MONTH), '1') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "space#f96215b69d43/ansi_on",
-      "reason": "SELECT concat(space(array(1, 2)), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "space#f96215b69d43/ansi_off",
-      "reason": "SELECT concat(space(array(1, 2)), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/split_part.json b/tests/fixtures/analysis/registry-matrix/split_part.json
index b92cc5dbd..241b8bf55 100644
--- a/tests/fixtures/analysis/registry-matrix/split_part.json
+++ b/tests/fixtures/analysis/registry-matrix/split_part.json
@@ -8,14 +8,6 @@
       "id": "split_part#0976b41b4325/ansi_off",
       "reason": "SELECT split_part(INTERVAL '1-2' YEAR TO MONTH, '.', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "split_part#23f637e4e0cd/ansi_on",
-      "reason": "SELECT split_part('11.12.13', array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "split_part#23f637e4e0cd/ansi_off",
-      "reason": "SELECT split_part('11.12.13', array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "split_part#45999b18c3c3/ansi_on",
       "reason": "SELECT split_part('11.12.13', INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -40,14 +32,6 @@
       "id": "split_part#5684a16088e9/ansi_off",
       "reason": "SELECT split_part('11.12.13', '.', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "split_part#5adf1a59e6b4/ansi_on",
-      "reason": "SELECT split_part(array(1, 2), '.', 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "split_part#5adf1a59e6b4/ansi_off",
-      "reason": "SELECT split_part(array(1, 2), '.', 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "split_part#804bf5201c99/ansi_on",
       "reason": "SELECT split_part(INTERVAL '1 02:03:04' DAY TO SECOND, '.', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -80,14 +64,6 @@
       "id": "split_part#dd1e4d2ceaea/ansi_off",
       "reason": "SELECT split_part('11.12.13', map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "split_part#e029f06c30b5/ansi_on",
-      "reason": "SELECT split_part('11.12.13', '.', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "split_part#e029f06c30b5/ansi_off",
-      "reason": "SELECT split_part('11.12.13', '.', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "split_part#f852429f985a/ansi_on",
       "reason": "SELECT split_part('11.12.13', INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/sqrt.json b/tests/fixtures/analysis/registry-matrix/sqrt.json
index 434efb167..42eed0952 100644
--- a/tests/fixtures/analysis/registry-matrix/sqrt.json
+++ b/tests/fixtures/analysis/registry-matrix/sqrt.json
@@ -8,14 +8,6 @@
       "id": "sqrt#16036e88e7c1/ansi_off",
       "reason": "SELECT sqrt(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sqrt#4396783664f6/ansi_on",
-      "reason": "SELECT sqrt(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sqrt#4396783664f6/ansi_off",
-      "reason": "SELECT sqrt(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sqrt#4cf0f8ae607a/ansi_on",
       "reason": "SELECT sqrt(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/startswith.json b/tests/fixtures/analysis/registry-matrix/startswith.json
index f67d4250c..5cb7e549a 100644
--- a/tests/fixtures/analysis/registry-matrix/startswith.json
+++ b/tests/fixtures/analysis/registry-matrix/startswith.json
@@ -16,14 +16,6 @@
       "id": "startswith#19b35e358339/ansi_off",
       "reason": "SELECT startswith(INTERVAL '1-2' YEAR TO MONTH, 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "startswith#347720a57a55/ansi_on",
-      "reason": "SELECT startswith(array(1, 2), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "startswith#347720a57a55/ansi_off",
-      "reason": "SELECT startswith(array(1, 2), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "startswith#41a1cdde2774/ansi_on",
       "reason": "SELECT startswith('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -55,14 +47,6 @@
     {
       "id": "startswith#a56ab8af6405/ansi_off",
       "reason": "SELECT startswith('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "startswith#bf1ab845092b/ansi_on",
-      "reason": "SELECT startswith('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "startswith#bf1ab845092b/ansi_off",
-      "reason": "SELECT startswith('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/struct.json b/tests/fixtures/analysis/registry-matrix/struct.json
index b5aacf29e..9d0d0129f 100644
--- a/tests/fixtures/analysis/registry-matrix/struct.json
+++ b/tests/fixtures/analysis/registry-matrix/struct.json
@@ -8,14 +8,6 @@
       "id": "struct#0fc70328ef5f/ansi_off",
       "reason": "SELECT struct(1, 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "struct#2c5df2f35ff9/ansi_on",
-      "reason": "SELECT struct(array(1, 2), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "struct#2c5df2f35ff9/ansi_off",
-      "reason": "SELECT struct(array(1, 2), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "struct#3de026bd0cd4/ansi_on",
       "reason": "SELECT struct(1, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map"
@@ -48,14 +40,6 @@
       "id": "struct#5145e16a16a9/ansi_off",
       "reason": "SELECT struct(1, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map"
     },
-    {
-      "id": "struct#5346837348d2/ansi_on",
-      "reason": "SELECT struct(1, 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "struct#5346837348d2/ansi_off",
-      "reason": "SELECT struct(1, 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "struct#5f8c80f88ab9/ansi_on",
       "reason": "SELECT struct(1, INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -87,14 +71,6 @@
     {
       "id": "struct#e2beeee445bf/ansi_off",
       "reason": "SELECT struct(INTERVAL '1-2' YEAR TO MONTH, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "struct#ee27f4432a36/ansi_on",
-      "reason": "SELECT struct(1, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "struct#ee27f4432a36/ansi_off",
-      "reason": "SELECT struct(1, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/substr.json b/tests/fixtures/analysis/registry-matrix/substr.json
index 2eb81d025..d486b39ab 100644
--- a/tests/fixtures/analysis/registry-matrix/substr.json
+++ b/tests/fixtures/analysis/registry-matrix/substr.json
@@ -8,14 +8,6 @@
       "id": "substr#0d7df6c77a5b/ansi_off",
       "reason": "SELECT substr(INTERVAL '1 02:03:04' DAY TO SECOND, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "substr#16e9c6ed673b/ansi_on",
-      "reason": "SELECT substr('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#16e9c6ed673b/ansi_off",
-      "reason": "SELECT substr('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substr#1e76e4332cc3/ansi_on",
       "reason": "SELECT substr('Spark SQL', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -24,14 +16,6 @@
       "id": "substr#1e76e4332cc3/ansi_off",
       "reason": "SELECT substr('Spark SQL', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substr#1eac62736f36/ansi_on",
-      "reason": "SELECT substr('Spark SQL', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#1eac62736f36/ansi_off",
-      "reason": "SELECT substr('Spark SQL', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substr#29ec6f65af26/ansi_on",
       "reason": "SELECT substr('Spark SQL', INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -56,14 +40,6 @@
       "id": "substr#4f609ceaa310/ansi_off",
       "reason": "SELECT substr('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substr#5098f3bdd376/ansi_on",
-      "reason": "SELECT substr(array(1, 2), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#5098f3bdd376/ansi_off",
-      "reason": "SELECT substr(array(1, 2), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substr#723f8b45fc39/ansi_on",
       "reason": "SELECT substr('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -120,14 +96,6 @@
       "id": "substr#a02122420647/ansi_off",
       "reason": "SELECT substr('Spark SQL', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substr#b67f2937523e/ansi_on",
-      "reason": "SELECT substr(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#b67f2937523e/ansi_off",
-      "reason": "SELECT substr(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substr#db430fd33e45/ansi_on",
       "reason": "SELECT substr('Spark SQL', map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -136,14 +104,6 @@
       "id": "substr#db430fd33e45/ansi_off",
       "reason": "SELECT substr('Spark SQL', map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substr#f38c9880f41b/ansi_on",
-      "reason": "SELECT substr('Spark SQL', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#f38c9880f41b/ansi_off",
-      "reason": "SELECT substr('Spark SQL', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substr#f4b691e3b8ea/ansi_on",
       "reason": "SELECT substr(INTERVAL '1-2' YEAR TO MONTH, 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/substring.json b/tests/fixtures/analysis/registry-matrix/substring.json
index 7e3685421..ac12423bc 100644
--- a/tests/fixtures/analysis/registry-matrix/substring.json
+++ b/tests/fixtures/analysis/registry-matrix/substring.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "substring#031cf9986895/ansi_on",
-      "reason": "SELECT substring('Spark SQL', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#031cf9986895/ansi_off",
-      "reason": "SELECT substring('Spark SQL', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substring#0adf3efa005d/ansi_on",
       "reason": "SELECT substring('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -64,14 +56,6 @@
       "id": "substring#3f2624e3879f/ansi_off",
       "reason": "SELECT substring('Spark SQL', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substring#4bce01c80b91/ansi_on",
-      "reason": "SELECT substring(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#4bce01c80b91/ansi_off",
-      "reason": "SELECT substring(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substring#525e241ea7f0/ansi_on",
       "reason": "SELECT substring(INTERVAL '1-2' YEAR TO MONTH, 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -88,14 +72,6 @@
       "id": "substring#6372499e9a5a/ansi_off",
       "reason": "SELECT substring(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substring#826898b7fd31/ansi_on",
-      "reason": "SELECT substring(array(1, 2), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#826898b7fd31/ansi_off",
-      "reason": "SELECT substring(array(1, 2), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substring#8b42b0b920a8/ansi_on",
       "reason": "SELECT substring('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -112,14 +88,6 @@
       "id": "substring#8b6b79a607c1/ansi_off",
       "reason": "SELECT substring(INTERVAL '1 02:03:04' DAY TO SECOND, 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "substring#95381cdc26f5/ansi_on",
-      "reason": "SELECT substring('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#95381cdc26f5/ansi_off",
-      "reason": "SELECT substring('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substring#9715e4291ca1/ansi_on",
       "reason": "SELECT substring(INTERVAL '1 02:03:04' DAY TO SECOND, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -151,14 +119,6 @@
     {
       "id": "substring#d0a9e5313045/ansi_off",
       "reason": "SELECT substring('Spark SQL', map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#f51d6ccadba4/ansi_on",
-      "reason": "SELECT substring('Spark SQL', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#f51d6ccadba4/ansi_off",
-      "reason": "SELECT substring('Spark SQL', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/substring_index.json b/tests/fixtures/analysis/registry-matrix/substring_index.json
index 76b6e10a0..3ccafb31d 100644
--- a/tests/fixtures/analysis/registry-matrix/substring_index.json
+++ b/tests/fixtures/analysis/registry-matrix/substring_index.json
@@ -16,14 +16,6 @@
       "id": "substring_index#3891f2bca04a/ansi_off",
       "reason": "SELECT substring_index('www.apache.org', '.', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substring_index#431d84dbcf7a/ansi_on",
-      "reason": "SELECT substring_index('www.apache.org', '.', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring_index#431d84dbcf7a/ansi_off",
-      "reason": "SELECT substring_index('www.apache.org', '.', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substring_index#52f4898847e9/ansi_on",
       "reason": "SELECT substring_index('www.apache.org', '.', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,22 +32,6 @@
       "id": "substring_index#8dcf07f370c5/ansi_off",
       "reason": "SELECT substring_index(map('a', 1), '.', 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substring_index#9c979ef1f520/ansi_on",
-      "reason": "SELECT substring_index(array(1, 2), '.', 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring_index#9c979ef1f520/ansi_off",
-      "reason": "SELECT substring_index(array(1, 2), '.', 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring_index#a6fe796b7f5b/ansi_on",
-      "reason": "SELECT substring_index('www.apache.org', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring_index#a6fe796b7f5b/ansi_off",
-      "reason": "SELECT substring_index('www.apache.org', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substring_index#ab14b0f764a7/ansi_on",
       "reason": "SELECT substring_index(INTERVAL '1 02:03:04' DAY TO SECOND, '.', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/tan.json b/tests/fixtures/analysis/registry-matrix/tan.json
index 0215dcc6c..fc2f00d04 100644
--- a/tests/fixtures/analysis/registry-matrix/tan.json
+++ b/tests/fixtures/analysis/registry-matrix/tan.json
@@ -23,14 +23,6 @@
     {
       "id": "tan#eef3973d8de1/ansi_off",
       "reason": "SELECT tan(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "tan#f60468d721a2/ansi_on",
-      "reason": "SELECT tan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "tan#f60468d721a2/ansi_off",
-      "reason": "SELECT tan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/tanh.json b/tests/fixtures/analysis/registry-matrix/tanh.json
index 734b85cae..caab3a027 100644
--- a/tests/fixtures/analysis/registry-matrix/tanh.json
+++ b/tests/fixtures/analysis/registry-matrix/tanh.json
@@ -8,14 +8,6 @@
       "id": "tanh#054342254ba1/ansi_off",
       "reason": "SELECT tanh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "tanh#bbec36e28d72/ansi_on",
-      "reason": "SELECT tanh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "tanh#bbec36e28d72/ansi_off",
-      "reason": "SELECT tanh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "tanh#bc60aa3cc8fe/ansi_on",
       "reason": "SELECT tanh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/to_binary.json b/tests/fixtures/analysis/registry-matrix/to_binary.json
index dccb40264..594b1175b 100644
--- a/tests/fixtures/analysis/registry-matrix/to_binary.json
+++ b/tests/fixtures/analysis/registry-matrix/to_binary.json
@@ -48,14 +48,6 @@
       "id": "to_binary#3cf2a0779cfc/ansi_off",
       "reason": "SELECT to_binary('abc', named_struct('a', 1, 'b', 'x')) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE"
     },
-    {
-      "id": "to_binary#3f69e2c8f2f5/ansi_on",
-      "reason": "SELECT to_binary(array(1, 2), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "to_binary#3f69e2c8f2f5/ansi_off",
-      "reason": "SELECT to_binary(array(1, 2), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "to_binary#414f2deb9e85/ansi_on",
       "reason": "SELECT to_binary('abc', DATE'2024-02-29') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE"
@@ -98,11 +90,11 @@
     },
     {
       "id": "to_binary#94a597ad1e4e/ansi_on",
-      "reason": "SELECT to_binary('abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE"
+      "reason": "SELECT to_binary('abc', array(1, 2)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE"
     },
     {
       "id": "to_binary#94a597ad1e4e/ansi_off",
-      "reason": "SELECT to_binary('abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE"
+      "reason": "SELECT to_binary('abc', array(1, 2)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE"
     },
     {
       "id": "to_binary#94c4370a6b36/ansi_on",
diff --git a/tests/fixtures/analysis/registry-matrix/to_char.json b/tests/fixtures/analysis/registry-matrix/to_char.json
index c1cce6fe8..c509d1ecb 100644
--- a/tests/fixtures/analysis/registry-matrix/to_char.json
+++ b/tests/fixtures/analysis/registry-matrix/to_char.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "to_char#0e6f2a6c98ce/ansi_on",
-      "reason": "SELECT to_char(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "to_char#0e6f2a6c98ce/ansi_off",
-      "reason": "SELECT to_char(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "to_char#18b01e8066ef/ansi_on",
       "reason": "SELECT to_char(454, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_DIGIT"
@@ -16,14 +8,6 @@
       "id": "to_char#18b01e8066ef/ansi_off",
       "reason": "SELECT to_char(454, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_DIGIT"
     },
-    {
-      "id": "to_char#62ce9da6957b/ansi_on",
-      "reason": "SELECT to_char(454, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "to_char#62ce9da6957b/ansi_off",
-      "reason": "SELECT to_char(454, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "to_char#7c77983e5a32/ansi_on",
       "reason": "SELECT to_char(INTERVAL '1 02:03:04' DAY TO SECOND, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/to_number.json b/tests/fixtures/analysis/registry-matrix/to_number.json
index 0cd04b027..11f27407e 100644
--- a/tests/fixtures/analysis/registry-matrix/to_number.json
+++ b/tests/fixtures/analysis/registry-matrix/to_number.json
@@ -16,14 +16,6 @@
       "id": "to_number#2ac9fb75cd2c/ansi_off",
       "reason": "SELECT to_number(INTERVAL '1-2' YEAR TO MONTH, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "to_number#672ac52e1b84/ansi_on",
-      "reason": "SELECT to_number('454', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "to_number#672ac52e1b84/ansi_off",
-      "reason": "SELECT to_number('454', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "to_number#7e6e35712586/ansi_on",
       "reason": "SELECT to_number('454', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_TOKEN"
@@ -40,14 +32,6 @@
       "id": "to_number#8152f955c6c4/ansi_off",
       "reason": "SELECT to_number('454', TIMESTAMP'2024-02-29 12:34:56.123456') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has INVALID_FORMAT.UNEXPECTED_TOKEN"
     },
-    {
-      "id": "to_number#8d4c3a7592dc/ansi_on",
-      "reason": "SELECT to_number(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "to_number#8d4c3a7592dc/ansi_off",
-      "reason": "SELECT to_number(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "to_number#8e822c2c1477/ansi_on",
       "reason": "SELECT to_number(INTERVAL '1 02:03:04' DAY TO SECOND, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json b/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json
index 1ff1e6701..dfb1ffe25 100644
--- a/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json
+++ b/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json
@@ -32,22 +32,6 @@
       "id": "to_utc_timestamp#4007b97e1f30/ansi_off",
       "reason": "SELECT to_utc_timestamp('2016-08-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "to_utc_timestamp#6e393f2bd812/ansi_on",
-      "reason": "SELECT to_utc_timestamp(array(1, 2), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "to_utc_timestamp#6e393f2bd812/ansi_off",
-      "reason": "SELECT to_utc_timestamp(array(1, 2), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "to_utc_timestamp#78b01f86bbd7/ansi_on",
-      "reason": "SELECT to_utc_timestamp('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "to_utc_timestamp#78b01f86bbd7/ansi_off",
-      "reason": "SELECT to_utc_timestamp('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "to_utc_timestamp#9ec1404ab832/ansi_on",
       "reason": "SELECT to_utc_timestamp(map('a', 1), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/to_varchar.json b/tests/fixtures/analysis/registry-matrix/to_varchar.json
index cc6a5f14b..1fc90d48f 100644
--- a/tests/fixtures/analysis/registry-matrix/to_varchar.json
+++ b/tests/fixtures/analysis/registry-matrix/to_varchar.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "to_varchar#0bac32cbaaef/ansi_on",
-      "reason": "SELECT to_varchar(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "to_varchar#0bac32cbaaef/ansi_off",
-      "reason": "SELECT to_varchar(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "to_varchar#36f98b6cd322/ansi_on",
       "reason": "SELECT to_varchar(454, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_DIGIT"
@@ -56,14 +48,6 @@
       "id": "to_varchar#9f23b08b45e0/ansi_off",
       "reason": "SELECT to_varchar(INTERVAL '1-2' YEAR TO MONTH, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "to_varchar#cce983c75f34/ansi_on",
-      "reason": "SELECT to_varchar(454, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "to_varchar#cce983c75f34/ansi_off",
-      "reason": "SELECT to_varchar(454, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "to_varchar#ebf434f037b3/ansi_on",
       "reason": "SELECT to_varchar(454, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/transform.json b/tests/fixtures/analysis/registry-matrix/transform.json
new file mode 100644
index 000000000..e1b08097c
--- /dev/null
+++ b/tests/fixtures/analysis/registry-matrix/transform.json
@@ -0,0 +1,30 @@
+{
+  "entries": [
+    {
+      "id": "transform#22257e088307/ansi_on",
+      "reason": "SELECT transform(INTERVAL '1-2' YEAR TO MONTH, x -> x + 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "transform#22257e088307/ansi_off",
+      "reason": "SELECT transform(INTERVAL '1-2' YEAR TO MONTH, x -> x + 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "transform#5724275e0d67/ansi_on",
+      "reason": "SELECT transform(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x + 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "transform#5724275e0d67/ansi_off",
+      "reason": "SELECT transform(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x + 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "transform#5819dd452d8e/ansi_on",
+      "reason": "SELECT transform(map('a', 1), x -> x + 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    },
+    {
+      "id": "transform#5819dd452d8e/ansi_off",
+      "reason": "SELECT transform(map('a', 1), x -> x + 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+    }
+  ],
+  "format_version": 1,
+  "function": "transform"
+}
diff --git a/tests/fixtures/analysis/registry-matrix/translate.json b/tests/fixtures/analysis/registry-matrix/translate.json
index 6fdfe23b8..28807cda9 100644
--- a/tests/fixtures/analysis/registry-matrix/translate.json
+++ b/tests/fixtures/analysis/registry-matrix/translate.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "translate#02831dc1fd11/ansi_on",
-      "reason": "SELECT translate('AaBbCc', 'abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "translate#02831dc1fd11/ansi_off",
-      "reason": "SELECT translate('AaBbCc', 'abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "translate#3fe19d6d2609/ansi_on",
       "reason": "SELECT translate(map('a', 1), 'abc', '123') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -40,14 +32,6 @@
       "id": "translate#6b471fcf6248/ansi_off",
       "reason": "SELECT translate('AaBbCc', 'abc', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "translate#6f4febf94e54/ansi_on",
-      "reason": "SELECT translate('AaBbCc', array(1, 2), '123') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "translate#6f4febf94e54/ansi_off",
-      "reason": "SELECT translate('AaBbCc', array(1, 2), '123') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "translate#7ef5ac648b85/ansi_on",
       "reason": "SELECT translate('AaBbCc', map('a', 1), '123') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -87,14 +71,6 @@
     {
       "id": "translate#c7809497221c/ansi_off",
       "reason": "SELECT translate('AaBbCc', INTERVAL '1-2' YEAR TO MONTH, '123') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "translate#cd0fe885b0f0/ansi_on",
-      "reason": "SELECT translate(array(1, 2), 'abc', '123') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "translate#cd0fe885b0f0/ansi_off",
-      "reason": "SELECT translate(array(1, 2), 'abc', '123') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/trim.json b/tests/fixtures/analysis/registry-matrix/trim.json
index d56c380bd..044f75c29 100644
--- a/tests/fixtures/analysis/registry-matrix/trim.json
+++ b/tests/fixtures/analysis/registry-matrix/trim.json
@@ -16,14 +16,6 @@
       "id": "trim#eb0fa3d83d97/ansi_off",
       "reason": "SELECT trim(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "trim#f04e4c7ecbdb/ansi_on",
-      "reason": "SELECT trim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "trim#f04e4c7ecbdb/ansi_off",
-      "reason": "SELECT trim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "trim#ff7e17fd365a/ansi_on",
       "reason": "SELECT trim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/trunc.json b/tests/fixtures/analysis/registry-matrix/trunc.json
index 3ceddd35a..3eb679956 100644
--- a/tests/fixtures/analysis/registry-matrix/trunc.json
+++ b/tests/fixtures/analysis/registry-matrix/trunc.json
@@ -16,22 +16,6 @@
       "id": "trunc#3f6bf3a87eef/ansi_off",
       "reason": "SELECT trunc(map('a', 1), 'week') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "trunc#46ec428ec220/ansi_on",
-      "reason": "SELECT trunc(array(1, 2), 'week') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "trunc#46ec428ec220/ansi_off",
-      "reason": "SELECT trunc(array(1, 2), 'week') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "trunc#57ac9a2715da/ansi_on",
-      "reason": "SELECT trunc('2019-08-04', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "trunc#57ac9a2715da/ansi_off",
-      "reason": "SELECT trunc('2019-08-04', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "trunc#a25de6ca5aa9/ansi_on",
       "reason": "SELECT trunc(INTERVAL '1-2' YEAR TO MONTH, 'week') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/try_add.json b/tests/fixtures/analysis/registry-matrix/try_add.json
index b8dafcc65..07461a0a6 100644
--- a/tests/fixtures/analysis/registry-matrix/try_add.json
+++ b/tests/fixtures/analysis/registry-matrix/try_add.json
@@ -124,14 +124,6 @@
       "id": "try_add#7227d469fb93/ansi_off",
       "reason": "SELECT try_add(CAST(NULL AS timestamp), interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "try_add#7b854b6fa631/ansi_on",
-      "reason": "SELECT try_add(1, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_add#7b854b6fa631/ansi_off",
-      "reason": "SELECT try_add(1, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_add#7d65f7b45439/ansi_on",
       "reason": "SELECT try_add(1, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -216,14 +208,6 @@
       "id": "try_add#cef78fc236ba/ansi_off",
       "reason": "SELECT try_add(INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "try_add#d0e88d1d20b6/ansi_on",
-      "reason": "SELECT try_add(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_add#d0e88d1d20b6/ansi_off",
-      "reason": "SELECT try_add(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_add#ddadaf94c15e/ansi_on",
       "reason": "SELECT try_add(CAST(NULL AS interval year), interval 2 year) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
diff --git a/tests/fixtures/analysis/registry-matrix/try_divide.json b/tests/fixtures/analysis/registry-matrix/try_divide.json
index c5685d276..43658f719 100644
--- a/tests/fixtures/analysis/registry-matrix/try_divide.json
+++ b/tests/fixtures/analysis/registry-matrix/try_divide.json
@@ -16,14 +16,6 @@
       "id": "try_divide#438928ec5060/ansi_off",
       "reason": "SELECT try_divide(INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "try_divide#57472aca288d/ansi_on",
-      "reason": "SELECT try_divide(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_divide#57472aca288d/ansi_off",
-      "reason": "SELECT try_divide(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_divide#5a3a4d187961/ansi_off",
       "reason": "SELECT try_divide('1', 2) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
@@ -92,14 +84,6 @@
       "id": "try_divide#d477c1bee5e3/ansi_off",
       "reason": "SELECT try_divide(3, '1') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "try_divide#fa21be3af2ec/ansi_on",
-      "reason": "SELECT try_divide(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_divide#fa21be3af2ec/ansi_off",
-      "reason": "SELECT try_divide(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_divide#ff290cce7e9e/ansi_off",
       "reason": "SELECT try_divide('abc', 2) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
diff --git a/tests/fixtures/analysis/registry-matrix/try_mod.json b/tests/fixtures/analysis/registry-matrix/try_mod.json
index 0d3b5e078..900fc32ae 100644
--- a/tests/fixtures/analysis/registry-matrix/try_mod.json
+++ b/tests/fixtures/analysis/registry-matrix/try_mod.json
@@ -56,14 +56,6 @@
       "id": "try_mod#96321dd79abb/ansi_off",
       "reason": "SELECT try_mod('1', 2) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "try_mod#b75bbd5e7fae/ansi_on",
-      "reason": "SELECT try_mod(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_mod#b75bbd5e7fae/ansi_off",
-      "reason": "SELECT try_mod(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_mod#e8377e2c5a5d/ansi_on",
       "reason": "SELECT try_mod(3, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -71,14 +63,6 @@
     {
       "id": "try_mod#e8377e2c5a5d/ansi_off",
       "reason": "SELECT try_mod(3, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_mod#f62535c1ea84/ansi_on",
-      "reason": "SELECT try_mod(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_mod#f62535c1ea84/ansi_off",
-      "reason": "SELECT try_mod(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/try_multiply.json b/tests/fixtures/analysis/registry-matrix/try_multiply.json
index 899451e17..47848d75f 100644
--- a/tests/fixtures/analysis/registry-matrix/try_multiply.json
+++ b/tests/fixtures/analysis/registry-matrix/try_multiply.json
@@ -8,14 +8,6 @@
       "id": "try_multiply#0a188b342bda/ansi_off",
       "reason": "SELECT try_multiply(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "try_multiply#2a85c0d45242/ansi_on",
-      "reason": "SELECT try_multiply(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_multiply#2a85c0d45242/ansi_off",
-      "reason": "SELECT try_multiply(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_multiply#31933e3dbf90/ansi_on",
       "reason": "SELECT try_multiply(CAST(NULL AS interval year), 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
@@ -84,14 +76,6 @@
       "id": "try_multiply#aaf5bd990a45/ansi_off",
       "reason": "SELECT try_multiply('1', 3) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "try_multiply#c3b02618e954/ansi_on",
-      "reason": "SELECT try_multiply(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_multiply#c3b02618e954/ansi_off",
-      "reason": "SELECT try_multiply(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_multiply#f8aceea556aa/ansi_off",
       "reason": "SELECT try_multiply('abc', 3) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
diff --git a/tests/fixtures/analysis/registry-matrix/try_parse_url.json b/tests/fixtures/analysis/registry-matrix/try_parse_url.json
index 1ad213a7f..e3a7ea03b 100644
--- a/tests/fixtures/analysis/registry-matrix/try_parse_url.json
+++ b/tests/fixtures/analysis/registry-matrix/try_parse_url.json
@@ -48,22 +48,6 @@
       "id": "try_parse_url#2c278d2df488/ansi_off",
       "reason": "SELECT try_parse_url(INTERVAL '1 02:03:04' DAY TO SECOND, 'QUERY', 'query') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "try_parse_url#2f2160c3f4d6/ansi_on",
-      "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', 'QUERY', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_parse_url#2f2160c3f4d6/ansi_off",
-      "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', 'QUERY', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_parse_url#3139f4305d1e/ansi_on",
-      "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', array(1, 2), 'query') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_parse_url#3139f4305d1e/ansi_off",
-      "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', array(1, 2), 'query') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "try_parse_url#37c0beb26184/ansi_on",
       "reason": "SELECT try_parse_url(map('a', 1), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -104,22 +88,6 @@
       "id": "try_parse_url#99a7f2da2ece/ansi_off",
       "reason": "SELECT try_parse_url(INTERVAL '1-2' YEAR TO MONTH, 'HOST') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "try_parse_url#a57c3080ae13/ansi_on",
-      "reason": "SELECT try_parse_url(array(1, 2), 'HOST') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_parse_url#a57c3080ae13/ansi_off",
-      "reason": "SELECT try_parse_url(array(1, 2), 'HOST') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_parse_url#ab5a2caeb7d9/ansi_on",
-      "reason": "SELECT try_parse_url(array(1, 2), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_parse_url#ab5a2caeb7d9/ansi_off",
-      "reason": "SELECT try_parse_url(array(1, 2), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "try_parse_url#adc8c07a0fc6/ansi_on",
       "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -144,14 +112,6 @@
       "id": "try_parse_url#dc20bfc7ef6c/ansi_off",
       "reason": "SELECT try_parse_url(INTERVAL '1-2' YEAR TO MONTH, 'QUERY', 'query') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "try_parse_url#e67e3e47b859/ansi_on",
-      "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_parse_url#e67e3e47b859/ansi_off",
-      "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "try_parse_url#ed610281c5cc/ansi_on",
       "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', INTERVAL '1-2' YEAR TO MONTH, 'query') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/try_subtract.json b/tests/fixtures/analysis/registry-matrix/try_subtract.json
index 4ed27223b..10e33cd40 100644
--- a/tests/fixtures/analysis/registry-matrix/try_subtract.json
+++ b/tests/fixtures/analysis/registry-matrix/try_subtract.json
@@ -4,14 +4,6 @@
       "id": "try_subtract#0edc9301ffa2/ansi_off",
       "reason": "SELECT try_subtract(2, '1') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "try_subtract#11f4067daafd/ansi_on",
-      "reason": "SELECT try_subtract(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_subtract#11f4067daafd/ansi_off",
-      "reason": "SELECT try_subtract(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_subtract#170516e36186/ansi_on",
       "reason": "SELECT try_subtract(2, TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -148,14 +140,6 @@
       "id": "try_subtract#901361175675/ansi_off",
       "reason": "SELECT try_subtract(2, 'abc') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "try_subtract#922f04f83a9d/ansi_on",
-      "reason": "SELECT try_subtract(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_subtract#922f04f83a9d/ansi_off",
-      "reason": "SELECT try_subtract(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_subtract#a275842dc947/ansi_on",
       "reason": "SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/try_to_binary.json b/tests/fixtures/analysis/registry-matrix/try_to_binary.json
index 150e06d29..4b630a479 100644
--- a/tests/fixtures/analysis/registry-matrix/try_to_binary.json
+++ b/tests/fixtures/analysis/registry-matrix/try_to_binary.json
@@ -34,11 +34,11 @@
     },
     {
       "id": "try_to_binary#1bcae11a717a/ansi_on",
-      "reason": "SELECT try_to_binary('abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE"
+      "reason": "SELECT try_to_binary('abc', array(1, 2)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE"
     },
     {
       "id": "try_to_binary#1bcae11a717a/ansi_off",
-      "reason": "SELECT try_to_binary('abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE"
+      "reason": "SELECT try_to_binary('abc', array(1, 2)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE"
     },
     {
       "id": "try_to_binary#2c59e7e42dfd/ansi_on",
@@ -128,14 +128,6 @@
       "id": "try_to_binary#b50b91b76ee5/ansi_off",
       "reason": "SELECT try_to_binary('abc', DATE'2024-02-29') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT"
     },
-    {
-      "id": "try_to_binary#cc59cfaeb480/ansi_on",
-      "reason": "SELECT try_to_binary(array(1, 2), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_to_binary#cc59cfaeb480/ansi_off",
-      "reason": "SELECT try_to_binary(array(1, 2), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "try_to_binary#e1d6e9aec2fc/ansi_on",
       "reason": "SELECT try_to_binary('abc', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/try_to_number.json b/tests/fixtures/analysis/registry-matrix/try_to_number.json
index 7ac8cfcae..426f79807 100644
--- a/tests/fixtures/analysis/registry-matrix/try_to_number.json
+++ b/tests/fixtures/analysis/registry-matrix/try_to_number.json
@@ -32,14 +32,6 @@
       "id": "try_to_number#45bb6eb12996/ansi_off",
       "reason": "SELECT try_to_number(map('a', 1), '999') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "try_to_number#69b8cbb7518e/ansi_on",
-      "reason": "SELECT try_to_number('454', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_to_number#69b8cbb7518e/ansi_off",
-      "reason": "SELECT try_to_number('454', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "try_to_number#77409df43665/ansi_on",
       "reason": "SELECT try_to_number('454', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has INVALID_FORMAT.UNEXPECTED_TOKEN"
@@ -56,14 +48,6 @@
       "id": "try_to_number#782169bd58ea/ansi_off",
       "reason": "SELECT try_to_number('454', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_DIGIT"
     },
-    {
-      "id": "try_to_number#9f910a6cefde/ansi_on",
-      "reason": "SELECT try_to_number(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_to_number#9f910a6cefde/ansi_off",
-      "reason": "SELECT try_to_number(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "try_to_number#b758b382c427/ansi_on",
       "reason": "SELECT try_to_number(INTERVAL '1 02:03:04' DAY TO SECOND, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/try_url_decode.json b/tests/fixtures/analysis/registry-matrix/try_url_decode.json
index f3ed89335..8b12e7cf0 100644
--- a/tests/fixtures/analysis/registry-matrix/try_url_decode.json
+++ b/tests/fixtures/analysis/registry-matrix/try_url_decode.json
@@ -1,13 +1,5 @@
 {
   "entries": [
-    {
-      "id": "try_url_decode#53ce22b52e5d/ansi_on",
-      "reason": "SELECT try_url_decode(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_url_decode#53ce22b52e5d/ansi_off",
-      "reason": "SELECT try_url_decode(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "try_url_decode#6344512c210e/ansi_on",
       "reason": "SELECT try_url_decode(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/try_validate_utf8.json b/tests/fixtures/analysis/registry-matrix/try_validate_utf8.json
index 8f007414c..15936a607 100644
--- a/tests/fixtures/analysis/registry-matrix/try_validate_utf8.json
+++ b/tests/fixtures/analysis/registry-matrix/try_validate_utf8.json
@@ -23,14 +23,6 @@
     {
       "id": "try_validate_utf8#eeb67f464482/ansi_off",
       "reason": "SELECT try_validate_utf8(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "try_validate_utf8#f7aa6c5cf167/ansi_on",
-      "reason": "SELECT try_validate_utf8(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "try_validate_utf8#f7aa6c5cf167/ansi_off",
-      "reason": "SELECT try_validate_utf8(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/typeof.json b/tests/fixtures/analysis/registry-matrix/typeof.json
index 57307746d..fa1942275 100644
--- a/tests/fixtures/analysis/registry-matrix/typeof.json
+++ b/tests/fixtures/analysis/registry-matrix/typeof.json
@@ -16,38 +16,6 @@
       "id": "typeof#85119c3e6111/ansi_off",
       "reason": "SELECT typeof(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "typeof#86964662cdab/ansi_on",
-      "reason": "SELECT typeof(array(1)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "typeof#86964662cdab/ansi_off",
-      "reason": "SELECT typeof(array(1)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "typeof#8b64929c858b/ansi_on",
-      "reason": "SELECT typeof(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "typeof#8b64929c858b/ansi_off",
-      "reason": "SELECT typeof(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "typeof#94be9d2b4025/ansi_on",
-      "reason": "SELECT typeof(CAST(array() AS array<int>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "typeof#94be9d2b4025/ansi_off",
-      "reason": "SELECT typeof(CAST(array() AS array<int>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "typeof#bea7c4b2a1ca/ansi_on",
-      "reason": "SELECT typeof(CAST(array(NULL) AS array<int>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "typeof#bea7c4b2a1ca/ansi_off",
-      "reason": "SELECT typeof(CAST(array(NULL) AS array<int>)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "typeof#ef1847dcc457/ansi_on",
       "reason": "SELECT typeof(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/ucase.json b/tests/fixtures/analysis/registry-matrix/ucase.json
index 6e1e4825c..93863e991 100644
--- a/tests/fixtures/analysis/registry-matrix/ucase.json
+++ b/tests/fixtures/analysis/registry-matrix/ucase.json
@@ -8,14 +8,6 @@
       "id": "ucase#05ac574f466d/ansi_off",
       "reason": "SELECT ucase(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "ucase#7d9d4bbe7436/ansi_on",
-      "reason": "SELECT ucase(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ucase#7d9d4bbe7436/ansi_off",
-      "reason": "SELECT ucase(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ucase#9de2d667346e/ansi_on",
       "reason": "SELECT ucase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/unbase64.json b/tests/fixtures/analysis/registry-matrix/unbase64.json
index 0bcb1daf6..7294d1470 100644
--- a/tests/fixtures/analysis/registry-matrix/unbase64.json
+++ b/tests/fixtures/analysis/registry-matrix/unbase64.json
@@ -23,14 +23,6 @@
     {
       "id": "unbase64#869cbd3a6b3e/ansi_off",
       "reason": "SELECT unbase64(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "unbase64#cb59c52b8e72/ansi_on",
-      "reason": "SELECT unbase64(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "unbase64#cb59c52b8e72/ansi_off",
-      "reason": "SELECT unbase64(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/unhex.json b/tests/fixtures/analysis/registry-matrix/unhex.json
index 4e725491f..5c8e7a89c 100644
--- a/tests/fixtures/analysis/registry-matrix/unhex.json
+++ b/tests/fixtures/analysis/registry-matrix/unhex.json
@@ -23,14 +23,6 @@
     {
       "id": "unhex#4fe2346478a2/ansi_off",
       "reason": "SELECT decode(unhex(INTERVAL '1 02:03:04' DAY TO SECOND), 'UTF-8') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "unhex#b822eace082b/ansi_on",
-      "reason": "SELECT decode(unhex(array(1, 2)), 'UTF-8') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "unhex#b822eace082b/ansi_off",
-      "reason": "SELECT decode(unhex(array(1, 2)), 'UTF-8') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/uniform.json b/tests/fixtures/analysis/registry-matrix/uniform.json
index 05efb925d..900704b81 100644
--- a/tests/fixtures/analysis/registry-matrix/uniform.json
+++ b/tests/fixtures/analysis/registry-matrix/uniform.json
@@ -16,14 +16,6 @@
       "id": "uniform#1e99715e4fd3/ansi_off",
       "reason": "SELECT uniform(10, INTERVAL '1 02:03:04' DAY TO SECOND, 0) > 0 AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "uniform#30c2e2b398e9/ansi_on",
-      "reason": "SELECT uniform(array(1, 2), 20, 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "uniform#30c2e2b398e9/ansi_off",
-      "reason": "SELECT uniform(array(1, 2), 20, 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "uniform#310b01a5b4ae/ansi_on",
       "reason": "SELECT uniform(10, INTERVAL '1-2' YEAR TO MONTH, 0) > 0 AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -56,14 +48,6 @@
       "id": "uniform#5656d353ced6/ansi_off",
       "reason": "SELECT uniform(INTERVAL '1-2' YEAR TO MONTH, 20, 0) > 0 AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "uniform#5ff5470f6623/ansi_on",
-      "reason": "SELECT uniform(10, 20, array(1, 2)) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "uniform#5ff5470f6623/ansi_off",
-      "reason": "SELECT uniform(10, 20, array(1, 2)) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "uniform#681f70cb51f1/ansi_on",
       "reason": "SELECT uniform(map('a', 1), 20, 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -112,14 +96,6 @@
       "id": "uniform#ab6b99e0333b/ansi_off",
       "reason": "SELECT uniform(10, NULL, 0) > 0 AS result | boolean where Spark has boolean not null"
     },
-    {
-      "id": "uniform#ac2a6eb487eb/ansi_on",
-      "reason": "SELECT uniform(10, array(1, 2), 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "uniform#ac2a6eb487eb/ansi_off",
-      "reason": "SELECT uniform(10, array(1, 2), 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "uniform#d54a4a610339/ansi_on",
       "reason": "SELECT uniform(10, 20, map('a', 1)) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/unix_date.json b/tests/fixtures/analysis/registry-matrix/unix_date.json
index 193c7f9c8..9b8b79c3c 100644
--- a/tests/fixtures/analysis/registry-matrix/unix_date.json
+++ b/tests/fixtures/analysis/registry-matrix/unix_date.json
@@ -31,14 +31,6 @@
     {
       "id": "unix_date#da1a0a925766/ansi_off",
       "reason": "SELECT unix_date(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "unix_date#e49b5743d3da/ansi_on",
-      "reason": "SELECT unix_date(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "unix_date#e49b5743d3da/ansi_off",
-      "reason": "SELECT unix_date(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/upper.json b/tests/fixtures/analysis/registry-matrix/upper.json
index 52ae52182..61806e974 100644
--- a/tests/fixtures/analysis/registry-matrix/upper.json
+++ b/tests/fixtures/analysis/registry-matrix/upper.json
@@ -23,14 +23,6 @@
     {
       "id": "upper#a8ece98a87b6/ansi_off",
       "reason": "SELECT upper(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "upper#dc8ae8109118/ansi_on",
-      "reason": "SELECT upper(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "upper#dc8ae8109118/ansi_off",
-      "reason": "SELECT upper(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/url_decode.json b/tests/fixtures/analysis/registry-matrix/url_decode.json
index 135599e2b..4975c3868 100644
--- a/tests/fixtures/analysis/registry-matrix/url_decode.json
+++ b/tests/fixtures/analysis/registry-matrix/url_decode.json
@@ -16,14 +16,6 @@
       "id": "url_decode#4f5db2bf56bc/ansi_off",
       "reason": "SELECT url_decode(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "url_decode#6cdd00a08e12/ansi_on",
-      "reason": "SELECT url_decode(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "url_decode#6cdd00a08e12/ansi_off",
-      "reason": "SELECT url_decode(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "url_decode#c6e875897174/ansi_on",
       "reason": "SELECT url_decode(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/url_encode.json b/tests/fixtures/analysis/registry-matrix/url_encode.json
index 035f879c4..52c70fb91 100644
--- a/tests/fixtures/analysis/registry-matrix/url_encode.json
+++ b/tests/fixtures/analysis/registry-matrix/url_encode.json
@@ -8,14 +8,6 @@
       "id": "url_encode#49305c257f5f/ansi_off",
       "reason": "SELECT url_encode(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "url_encode#4ab6d97c0399/ansi_on",
-      "reason": "SELECT url_encode(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "url_encode#4ab6d97c0399/ansi_off",
-      "reason": "SELECT url_encode(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "url_encode#c70459c3420e/ansi_on",
       "reason": "SELECT url_encode(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/validate_utf8.json b/tests/fixtures/analysis/registry-matrix/validate_utf8.json
index ca1ea6796..3c7c93166 100644
--- a/tests/fixtures/analysis/registry-matrix/validate_utf8.json
+++ b/tests/fixtures/analysis/registry-matrix/validate_utf8.json
@@ -8,14 +8,6 @@
       "id": "validate_utf8#5b3fcb41b557/ansi_off",
       "reason": "SELECT validate_utf8(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "validate_utf8#a9ec0df4bda0/ansi_on",
-      "reason": "SELECT validate_utf8(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "validate_utf8#a9ec0df4bda0/ansi_off",
-      "reason": "SELECT validate_utf8(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "validate_utf8#c80b7193e8a7/ansi_on",
       "reason": "SELECT validate_utf8(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
diff --git a/tests/fixtures/analysis/registry-matrix/weekday.json b/tests/fixtures/analysis/registry-matrix/weekday.json
index c31d6f052..049038b85 100644
--- a/tests/fixtures/analysis/registry-matrix/weekday.json
+++ b/tests/fixtures/analysis/registry-matrix/weekday.json
@@ -8,14 +8,6 @@
       "id": "weekday#1534b8969a15/ansi_off",
       "reason": "SELECT weekday(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "weekday#9569b8dd944c/ansi_on",
-      "reason": "SELECT weekday(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "weekday#9569b8dd944c/ansi_off",
-      "reason": "SELECT weekday(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "weekday#a8e54d4f1e7a/ansi_on",
       "reason": "SELECT weekday(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/weekofyear.json b/tests/fixtures/analysis/registry-matrix/weekofyear.json
index 48ccf80e1..dc8706c3c 100644
--- a/tests/fixtures/analysis/registry-matrix/weekofyear.json
+++ b/tests/fixtures/analysis/registry-matrix/weekofyear.json
@@ -23,14 +23,6 @@
     {
       "id": "weekofyear#bae528dc4232/ansi_off",
       "reason": "SELECT weekofyear(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "weekofyear#cde71a2a9453/ansi_on",
-      "reason": "SELECT weekofyear(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "weekofyear#cde71a2a9453/ansi_off",
-      "reason": "SELECT weekofyear(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/xxhash64.json b/tests/fixtures/analysis/registry-matrix/xxhash64.json
index b459df878..9ee343e8c 100644
--- a/tests/fixtures/analysis/registry-matrix/xxhash64.json
+++ b/tests/fixtures/analysis/registry-matrix/xxhash64.json
@@ -1,61 +1,5 @@
 {
   "entries": [
-    {
-      "id": "xxhash64#04d801e25e35/ansi_on",
-      "reason": "SELECT xxhash64(CAST(NULL AS string), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#04d801e25e35/ansi_off",
-      "reason": "SELECT xxhash64(CAST(NULL AS string), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#095784466712/ansi_on",
-      "reason": "SELECT xxhash64(1.5D, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#095784466712/ansi_off",
-      "reason": "SELECT xxhash64(1.5D, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#13b30bbffb5a/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(1 AS TINYINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#13b30bbffb5a/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(1 AS TINYINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#1446772cdb17/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS DECIMAL(38,18))) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#1446772cdb17/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS DECIMAL(38,18))) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#178bee7fcf10/ansi_on",
-      "reason": "SELECT xxhash64(CAST(1.5 AS FLOAT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#178bee7fcf10/ansi_off",
-      "reason": "SELECT xxhash64(CAST(1.5 AS FLOAT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#1c0a6e612b22/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#1c0a6e612b22/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#262bbf2d0fc5/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#262bbf2d0fc5/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "xxhash64#27bf617616cb/ansi_on",
       "reason": "SELECT xxhash64('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
@@ -64,29 +8,13 @@
       "id": "xxhash64#27bf617616cb/ansi_off",
       "reason": "SELECT xxhash64('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
     },
-    {
-      "id": "xxhash64#2c84929b4420/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#2c84929b4420/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "xxhash64#30b81390e09c/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
+      "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
     },
     {
       "id": "xxhash64#30b81390e09c/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
-    },
-    {
-      "id": "xxhash64#349ac41dfb58/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#349ac41dfb58/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array"
+      "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
     },
     {
       "id": "xxhash64#36cc90cab019/ansi_on",
@@ -96,30 +24,6 @@
       "id": "xxhash64#36cc90cab019/ansi_off",
       "reason": "SELECT xxhash64('Spark', array(123), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "xxhash64#3ca12993a520/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#3ca12993a520/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#3ebf8dfbd92e/ansi_on",
-      "reason": "SELECT xxhash64(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#3ebf8dfbd92e/ansi_off",
-      "reason": "SELECT xxhash64(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#3ed299546ff7/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), DATE'2024-02-29') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#3ed299546ff7/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), DATE'2024-02-29') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "xxhash64#46bae09a5a04/ansi_on",
       "reason": "SELECT xxhash64(INTERVAL '1-2' YEAR TO MONTH, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -128,118 +32,6 @@
       "id": "xxhash64#46bae09a5a04/ansi_off",
       "reason": "SELECT xxhash64(INTERVAL '1-2' YEAR TO MONTH, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "xxhash64#4de68e47e367/ansi_on",
-      "reason": "SELECT xxhash64('', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#4de68e47e367/ansi_off",
-      "reason": "SELECT xxhash64('', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#5b1bb149749b/ansi_on",
-      "reason": "SELECT xxhash64(1, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#5b1bb149749b/ansi_off",
-      "reason": "SELECT xxhash64(1, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#5f7f062051c0/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#5f7f062051c0/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#6175a87d7b79/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(2147483647 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#6175a87d7b79/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(2147483647 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#69b363904109/ansi_on",
-      "reason": "SELECT xxhash64('1', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#69b363904109/ansi_off",
-      "reason": "SELECT xxhash64('1', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#6c0515f68f16/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), 1L) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#6c0515f68f16/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), 1L) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#6c344a698829/ansi_on",
-      "reason": "SELECT xxhash64(CAST(1.5 AS DECIMAL(10,2)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#6c344a698829/ansi_off",
-      "reason": "SELECT xxhash64(CAST(1.5 AS DECIMAL(10,2)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#6c62c17e8044/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#6c62c17e8044/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#7146dfbaadba/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), 1.5D) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#7146dfbaadba/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), 1.5D) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#7a3e36bf27da/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS DECIMAL(10,2))) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#7a3e36bf27da/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS DECIMAL(10,2))) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#7f651b551773/ansi_on",
-      "reason": "SELECT xxhash64('abc', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#7f651b551773/ansi_off",
-      "reason": "SELECT xxhash64('abc', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#7fb8bab3c253/ansi_on",
-      "reason": "SELECT xxhash64(1L, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#7fb8bab3c253/ansi_off",
-      "reason": "SELECT xxhash64(1L, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#7fc5a11f73c0/ansi_on",
-      "reason": "SELECT xxhash64(' \\t a\\u3000\\n ', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#7fc5a11f73c0/ansi_off",
-      "reason": "SELECT xxhash64(' \\t a\\u3000\\n ', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#88be02abdc0a/ansi_on",
-      "reason": "SELECT xxhash64('Spark', CAST(array() AS array<int>), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#88be02abdc0a/ansi_off",
-      "reason": "SELECT xxhash64('Spark', CAST(array() AS array<int>), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "xxhash64#89b3d078d407/ansi_on",
       "reason": "SELECT xxhash64('Spark', INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -248,30 +40,6 @@
       "id": "xxhash64#89b3d078d407/ansi_off",
       "reason": "SELECT xxhash64('Spark', INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "xxhash64#900c868e26bb/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(NULL AS int)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#900c868e26bb/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(NULL AS int)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#a3f82a9411a5/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), X'01') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#a3f82a9411a5/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), X'01') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#a4386f4089b0/ansi_on",
-      "reason": "SELECT xxhash64(NULL, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#a4386f4089b0/ansi_off",
-      "reason": "SELECT xxhash64(NULL, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "xxhash64#aa4cafed551d/ansi_on",
       "reason": "SELECT xxhash64('Spark', INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -280,94 +48,6 @@
       "id": "xxhash64#aa4cafed551d/ansi_off",
       "reason": "SELECT xxhash64('Spark', INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "xxhash64#b8b7ba805159/ansi_on",
-      "reason": "SELECT xxhash64(CAST(1 AS TINYINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#b8b7ba805159/ansi_off",
-      "reason": "SELECT xxhash64(CAST(1 AS TINYINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#c1bdc4c0e4da/ansi_on",
-      "reason": "SELECT xxhash64(CAST(1 AS SMALLINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#c1bdc4c0e4da/ansi_off",
-      "reason": "SELECT xxhash64(CAST(1 AS SMALLINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#c46cdfcda1d4/ansi_on",
-      "reason": "SELECT xxhash64(CAST(1.5 AS DECIMAL(38,18)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#c46cdfcda1d4/ansi_off",
-      "reason": "SELECT xxhash64(CAST(1.5 AS DECIMAL(38,18)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#c4f7bcbebdee/ansi_on",
-      "reason": "SELECT xxhash64('Ä€日本語😀é', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#c4f7bcbebdee/ansi_off",
-      "reason": "SELECT xxhash64('Ä€日本語😀é', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#c695d37e19e8/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(1 AS SMALLINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#c695d37e19e8/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(1 AS SMALLINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#c9a780cf156a/ansi_on",
-      "reason": "SELECT xxhash64('Spark', CAST(array(NULL) AS array<int>), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#c9a780cf156a/ansi_off",
-      "reason": "SELECT xxhash64('Spark', CAST(array(NULL) AS array<int>), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#d38029db62a8/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#d38029db62a8/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#d90fd88f99d5/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(-2147483648 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#d90fd88f99d5/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(-2147483648 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#da904e59abfa/ansi_on",
-      "reason": "SELECT xxhash64(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#da904e59abfa/ansi_off",
-      "reason": "SELECT xxhash64(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#dd7cffaf7f2d/ansi_on",
-      "reason": "SELECT xxhash64(DATE'2024-02-29', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#dd7cffaf7f2d/ansi_off",
-      "reason": "SELECT xxhash64(DATE'2024-02-29', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#e03cf1df4795/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), 'abc') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#e03cf1df4795/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), 'abc') | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "xxhash64#e69ca7f985b4/ansi_on",
       "reason": "SELECT xxhash64('Spark', array(123), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -376,54 +56,6 @@
       "id": "xxhash64#e69ca7f985b4/ansi_off",
       "reason": "SELECT xxhash64('Spark', array(123), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "xxhash64#e988f0567582/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#e988f0567582/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#ed4eed24ba64/ansi_on",
-      "reason": "SELECT xxhash64(true, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#ed4eed24ba64/ansi_off",
-      "reason": "SELECT xxhash64(true, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#ee8d57c192df/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS FLOAT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#ee8d57c192df/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS FLOAT)) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#eea7d24d6cde/ansi_on",
-      "reason": "SELECT xxhash64(named_struct('a', 1, 'b', 'x'), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#eea7d24d6cde/ansi_off",
-      "reason": "SELECT xxhash64(named_struct('a', 1, 'b', 'x'), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#f20293a2a3c7/ansi_on",
-      "reason": "SELECT xxhash64(X'01', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#f20293a2a3c7/ansi_off",
-      "reason": "SELECT xxhash64(X'01', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#f37dcdf02cd4/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), true) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#f37dcdf02cd4/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), true) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "xxhash64#f5d3d559ad3a/ansi_on",
       "reason": "SELECT xxhash64(map('a', 1), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
@@ -432,14 +64,6 @@
       "id": "xxhash64#f5d3d559ad3a/ansi_off",
       "reason": "SELECT xxhash64(map('a', 1), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE"
     },
-    {
-      "id": "xxhash64#f79d45019309/ansi_on",
-      "reason": "SELECT xxhash64(CAST(X'C328FF' AS STRING), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#f79d45019309/ansi_off",
-      "reason": "SELECT xxhash64(CAST(X'C328FF' AS STRING), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
     {
       "id": "xxhash64#f916e9e6b8e7/ansi_on",
       "reason": "SELECT xxhash64(INTERVAL '1 02:03:04' DAY TO SECOND, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -447,14 +71,6 @@
     {
       "id": "xxhash64#f916e9e6b8e7/ansi_off",
       "reason": "SELECT xxhash64(INTERVAL '1 02:03:04' DAY TO SECOND, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "xxhash64#fb104518ccd7/ansi_on",
-      "reason": "SELECT xxhash64(array(1, 2), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
-    },
-    {
-      "id": "xxhash64#fb104518ccd7/ansi_off",
-      "reason": "SELECT xxhash64(array(1, 2), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     }
   ],
   "format_version": 1,
diff --git a/tests/fixtures/analysis/registry-matrix/year.json b/tests/fixtures/analysis/registry-matrix/year.json
index 9f4ae0e27..c51618a8f 100644
--- a/tests/fixtures/analysis/registry-matrix/year.json
+++ b/tests/fixtures/analysis/registry-matrix/year.json
@@ -8,14 +8,6 @@
       "id": "year#64d0616f8b51/ansi_off",
       "reason": "SELECT year(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "year#98b02509736a/ansi_on",
-      "reason": "SELECT year(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "year#98b02509736a/ansi_off",
-      "reason": "SELECT year(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "year#c5aacd8222e2/ansi_on",
       "reason": "SELECT year(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
diff --git a/tests/fixtures/analysis/registry-matrix/zeroifnull.json b/tests/fixtures/analysis/registry-matrix/zeroifnull.json
index 0d432fa56..5a619af46 100644
--- a/tests/fixtures/analysis/registry-matrix/zeroifnull.json
+++ b/tests/fixtures/analysis/registry-matrix/zeroifnull.json
@@ -8,14 +8,6 @@
       "id": "zeroifnull#525de99a30fd/ansi_off",
       "reason": "SELECT zeroifnull(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "zeroifnull#5369bb95092d/ansi_on",
-      "reason": "SELECT zeroifnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "zeroifnull#5369bb95092d/ansi_off",
-      "reason": "SELECT zeroifnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "zeroifnull#583a6c570fa6/ansi_on",
       "reason": "SELECT zeroifnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
diff --git a/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json b/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json
index 279bb83c6..65ece7641 100644
--- a/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json
+++ b/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json
@@ -2,75 +2,75 @@
   "entries": [
     {
       "query": "SELECT map_zip_with(array_map1, array_map2, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(decimal_map1, decimal_map2, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(decimal_map1, double_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(decimal_map1, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(decimal_map1, string_map4, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(decimal_map2, double_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(decimal_map2, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(double_map, float_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(float_infinity_map1, float_infinity_map2, (k, v1, v2) -> (v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors"
     },
     {
       "query": "SELECT map_zip_with(float_nan_map1, float_nan_map2, (k, v1, v2) -> (v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors"
     },
     {
       "query": "SELECT map_zip_with(float_zero_map, float_neg_zero_map, (k, v1, v2) -> (v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors"
     },
     {
       "query": "SELECT map_zip_with(int_map, bigint_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(smallint_map, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(string_map1, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(string_map2, date_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(struct_map1, struct_map2, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(timestamp_map, string_map3, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     },
     {
       "query": "SELECT map_zip_with(tinyint_map, smallint_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with"
     }
   ],
   "file": "typeCoercion/native/mapZipWith",
diff --git a/tests/spark-golden/known-failures-cases/array.json b/tests/spark-golden/known-failures-cases/array.json
index 299d8d06b..35c2bf99a 100644
--- a/tests/spark-golden/known-failures-cases/array.json
+++ b/tests/spark-golden/known-failures-cases/array.json
@@ -1,7 +1,6 @@
 {
   "cases": {
     "depends-on-command": [
-      1,
       2,
       3,
       5,
@@ -86,7 +85,6 @@
       62
     ],
     "sql-commands": [
-      0,
       4
     ]
   },
diff --git a/tests/spark-golden/known-failures-cases/except-all.json b/tests/spark-golden/known-failures-cases/except-all.json
deleted file mode 100644
index 21c292031..000000000
--- a/tests/spark-golden/known-failures-cases/except-all.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "cases": {
-    "depends-on-command": [
-      10
-    ]
-  },
-  "file": "except-all",
-  "format_version": 1
-}
diff --git a/tests/spark-golden/known-failures-cases/group-by-all-mosha.json b/tests/spark-golden/known-failures-cases/group-by-all-mosha.json
index bacb9cb20..947d7ad6f 100644
--- a/tests/spark-golden/known-failures-cases/group-by-all-mosha.json
+++ b/tests/spark-golden/known-failures-cases/group-by-all-mosha.json
@@ -1,19 +1,7 @@
 {
   "cases": {
     "depends-on-command": [
-      1,
-      2,
-      3,
-      4,
-      5,
-      6,
-      7,
-      8,
-      9,
-      10
-    ],
-    "sql-commands": [
-      0
+      4
     ]
   },
   "file": "group-by-all-mosha",
diff --git a/tests/spark-golden/known-failures-cases/having.json b/tests/spark-golden/known-failures-cases/having.json
index c2d5de2c4..34ae3e1c0 100644
--- a/tests/spark-golden/known-failures-cases/having.json
+++ b/tests/spark-golden/known-failures-cases/having.json
@@ -1,7 +1,6 @@
 {
   "cases": {
     "depends-on-command": [
-      3,
       28,
       29,
       30,
diff --git a/tests/spark-golden/known-failures-cases/higher-order-functions.json b/tests/spark-golden/known-failures-cases/higher-order-functions.json
index 8f222adbb..001a9b3d6 100644
--- a/tests/spark-golden/known-failures-cases/higher-order-functions.json
+++ b/tests/spark-golden/known-failures-cases/higher-order-functions.json
@@ -1,20 +1,13 @@
 {
   "cases": {
     "depends-on-command": [
-      3,
-      4,
-      5,
       6,
-      7,
-      9,
-      11,
       12,
       13,
       14,
       16,
       17,
       18,
-      20,
       22,
       26,
       27,
@@ -24,8 +17,6 @@
       31
     ],
     "hof": [
-      1,
-      2,
       23,
       24,
       34,
@@ -35,15 +26,9 @@
       39,
       40,
       42,
-      43,
       44,
-      46,
-      47,
       48,
-      50,
-      51,
       52,
-      54,
       55,
       56,
       58,
@@ -53,9 +38,7 @@
       63,
       64,
       66,
-      67,
       68,
-      70,
       71,
       72,
       74,
@@ -67,30 +50,18 @@
       82
     ],
     "nested-interval-types": [
-      8,
-      10,
       15,
       19,
-      21,
       37,
       41,
-      45,
-      49,
-      53,
       57,
       61,
       65,
-      69,
       73,
       77,
       81
     ],
-    "query-features": [
-      32,
-      33
-    ],
     "sql-commands": [
-      0,
       25
     ]
   },
diff --git a/tests/spark-golden/known-failures-cases/inline-table.json b/tests/spark-golden/known-failures-cases/inline-table.json
index 43b8b1554..7da5490ec 100644
--- a/tests/spark-golden/known-failures-cases/inline-table.json
+++ b/tests/spark-golden/known-failures-cases/inline-table.json
@@ -1,8 +1,6 @@
 {
   "cases": {
     "query-features": [
-      10,
-      14,
       18,
       22,
       23
diff --git a/tests/spark-golden/known-failures-cases/intersect-all.json b/tests/spark-golden/known-failures-cases/intersect-all.json
index 6a26b52ea..3130cc63d 100644
--- a/tests/spark-golden/known-failures-cases/intersect-all.json
+++ b/tests/spark-golden/known-failures-cases/intersect-all.json
@@ -1,7 +1,6 @@
 {
   "cases": {
     "depends-on-command": [
-      7,
       21,
       22
     ],
diff --git a/tests/spark-golden/known-failures-cases/join-lateral.json b/tests/spark-golden/known-failures-cases/join-lateral.json
index 64d19f2ff..e70c4a678 100644
--- a/tests/spark-golden/known-failures-cases/join-lateral.json
+++ b/tests/spark-golden/known-failures-cases/join-lateral.json
@@ -153,8 +153,6 @@
       1,
       2,
       3,
-      117,
-      123,
       154,
       155,
       156,
diff --git a/tests/spark-golden/known-failures-cases/literals.json b/tests/spark-golden/known-failures-cases/literals.json
index 2f14346bc..e0510e115 100644
--- a/tests/spark-golden/known-failures-cases/literals.json
+++ b/tests/spark-golden/known-failures-cases/literals.json
@@ -5,9 +5,6 @@
       45,
       52
     ],
-    "fn-array": [
-      48
-    ],
     "fn-map": [
       47
     ],
diff --git a/tests/spark-golden/known-failures-cases/nonansi/array.json b/tests/spark-golden/known-failures-cases/nonansi/array.json
index cd713db3e..ea787e368 100644
--- a/tests/spark-golden/known-failures-cases/nonansi/array.json
+++ b/tests/spark-golden/known-failures-cases/nonansi/array.json
@@ -1,7 +1,6 @@
 {
   "cases": {
     "depends-on-command": [
-      1,
       2,
       3,
       5,
@@ -86,7 +85,6 @@
       62
     ],
     "sql-commands": [
-      0,
       4
     ]
   },
diff --git a/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json b/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json
index a0f6f27d0..5190ea746 100644
--- a/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json
+++ b/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json
@@ -1,20 +1,13 @@
 {
   "cases": {
     "depends-on-command": [
-      3,
-      4,
-      5,
       6,
-      7,
-      9,
-      11,
       12,
       13,
       14,
       16,
       17,
       18,
-      20,
       22,
       26,
       27,
@@ -24,8 +17,6 @@
       31
     ],
     "hof": [
-      1,
-      2,
       23,
       24,
       34,
@@ -35,15 +26,9 @@
       39,
       40,
       42,
-      43,
       44,
-      46,
-      47,
       48,
-      50,
-      51,
       52,
-      54,
       55,
       56,
       58,
@@ -53,9 +38,7 @@
       63,
       64,
       66,
-      67,
       68,
-      70,
       71,
       72,
       74,
@@ -67,30 +50,18 @@
       82
     ],
     "nested-interval-types": [
-      8,
-      10,
       15,
       19,
-      21,
       37,
       41,
-      45,
-      49,
-      53,
       57,
       61,
       65,
-      69,
       73,
       77,
       81
     ],
-    "query-features": [
-      32,
-      33
-    ],
     "sql-commands": [
-      0,
       25
     ]
   },
diff --git a/tests/spark-golden/known-failures-cases/nonansi/literals.json b/tests/spark-golden/known-failures-cases/nonansi/literals.json
index d75bddcb8..91a5b6e86 100644
--- a/tests/spark-golden/known-failures-cases/nonansi/literals.json
+++ b/tests/spark-golden/known-failures-cases/nonansi/literals.json
@@ -5,9 +5,6 @@
       45,
       52
     ],
-    "fn-array": [
-      48
-    ],
     "fn-map": [
       47
     ],
diff --git a/tests/spark-golden/known-failures-cases/pipe-operators.json b/tests/spark-golden/known-failures-cases/pipe-operators.json
index 24f6ec290..9f42c7fa2 100644
--- a/tests/spark-golden/known-failures-cases/pipe-operators.json
+++ b/tests/spark-golden/known-failures-cases/pipe-operators.json
@@ -261,7 +261,6 @@
       7,
       8,
       12,
-      19,
       24,
       314,
       315,
diff --git a/tests/spark-golden/known-failures-cases/selectExcept.json b/tests/spark-golden/known-failures-cases/selectExcept.json
index 805dd2c57..12470fae2 100644
--- a/tests/spark-golden/known-failures-cases/selectExcept.json
+++ b/tests/spark-golden/known-failures-cases/selectExcept.json
@@ -10,8 +10,6 @@
       16,
       17,
       18,
-      29,
-      30,
       33,
       38,
       40,
diff --git a/tests/spark-golden/known-failures-cases/union.json b/tests/spark-golden/known-failures-cases/union.json
index d8377dc6e..274bf7b32 100644
--- a/tests/spark-golden/known-failures-cases/union.json
+++ b/tests/spark-golden/known-failures-cases/union.json
@@ -5,9 +5,6 @@
       14,
       15
     ],
-    "fn-array": [
-      11
-    ],
     "fn-map": [
       10
     ],