diff --git a/crates/krishiv-exec/src/planner/eval/mod.rs b/crates/krishiv-exec/src/planner/eval/mod.rs
index 266f0981..71fa2796 100644
--- a/crates/krishiv-exec/src/planner/eval/mod.rs
+++ b/crates/krishiv-exec/src/planner/eval/mod.rs
@@ -174,7 +174,7 @@ impl EvalEnv {
         let zone = config
             .get(&SESSION_TIME_ZONE)
             .and_then(|v| v.as_str())
-            .and_then(fixed_offset);
+            .and_then(|z| krishiv_kernels::cast::FixedOffset::parse(z).map(|o| o.0));
         let query_start_micros = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
             .ok()
@@ -211,25 +211,6 @@ impl EvalEnv {
     }
 }
 
-/// The offset of `UTC`, `GMT`, `Z` or `[+-]hh:mm`, in seconds.
-fn fixed_offset(zone: &str) -> Option<i32> {
-    if ["UTC", "GMT", "Z", "Etc/UTC"].contains(&zone) {
-        return Some(0);
-    }
-    let rest = zone
-        .strip_prefix("UTC")
-        .or_else(|| zone.strip_prefix("GMT"))
-        .unwrap_or(zone);
-    let (sign, hm) = match rest.as_bytes().first()? {
-        b'+' => (1, &rest[1..]),
-        b'-' => (-1, &rest[1..]),
-        _ => return None,
-    };
-    let (h, m) = hm.split_once(':').unwrap_or((hm, "0"));
-    let (h, m): (i32, i32) = (h.parse().ok()?, m.parse().ok()?);
-    ((0..=18).contains(&h) && (0..60).contains(&m)).then(|| sign * (h * 3600 + m * 60))
-}
-
 /// The input an expression is compiled against.
 #[derive(Clone, Copy)]
 pub(crate) struct Input<'a> {
diff --git a/crates/krishiv-kernels/src/cast.rs b/crates/krishiv-kernels/src/cast.rs
index abe59678..4272bb6c 100644
--- a/crates/krishiv-kernels/src/cast.rs
+++ b/crates/krishiv-kernels/src/cast.rs
@@ -38,7 +38,7 @@ use arrow_buffer::{NullBuffer, ScalarBuffer, i256};
 use arrow_schema::{DataType, TimeUnit};
 
 pub use datetime::{FixedOffset, TimeZoneRules};
-pub use timestamp::{TimestampText, timestamp_text};
+pub use timestamp::{TimestampText, timestamp_has_zone, timestamp_text};
 
 use crate::decimal::DecimalNative;
 use crate::error::{KernelError, with_capacity};
diff --git a/crates/krishiv-kernels/src/cast/datetime.rs b/crates/krishiv-kernels/src/cast/datetime.rs
index 3cd54a36..dc355052 100644
--- a/crates/krishiv-kernels/src/cast/datetime.rs
+++ b/crates/krishiv-kernels/src/cast/datetime.rs
@@ -39,6 +39,42 @@ impl TimeZoneRules for FixedOffset {
     }
 }
 
+impl FixedOffset {
+    /// The zone a `spark.sql.session.timeZone` value names, when it is a
+    /// fixed offset: `UTC`, `GMT`, `Z`, `Etc/UTC` or `[UTC|GMT][+-]hh[:mm]`
+    /// (hours up to 18). `None` for region ids, which need the time-zone
+    /// database, and for malformed zones.
+    #[must_use]
+    pub fn parse(zone: &str) -> Option<Self> {
+        let zone = zone.trim();
+        if ["UTC", "GMT", "Z", "Etc/UTC"].contains(&zone) {
+            return Some(Self(0));
+        }
+        let rest = zone
+            .strip_prefix("UTC")
+            .or_else(|| zone.strip_prefix("GMT"))
+            .unwrap_or(zone);
+        let (sign, hm) = match rest.as_bytes().first()? {
+            b'+' => (1, &rest[1..]),
+            b'-' => (-1, &rest[1..]),
+            _ => return None,
+        };
+        let (h_str, m_str) = hm.split_once(':').unwrap_or((hm, "0"));
+        // `i32::from_str` accepts a leading `+`/`-`, so `++5` or
+        // `+05:+30` would parse; require 1-2 ASCII digits per field.
+        if !(1..=2).contains(&h_str.len()) || !(1..=2).contains(&m_str.len()) {
+            return None;
+        }
+        if !h_str.bytes().all(|b| b.is_ascii_digit()) || !m_str.bytes().all(|b| b.is_ascii_digit())
+        {
+            return None;
+        }
+        let (h, m): (i32, i32) = (h_str.parse().ok()?, m_str.parse().ok()?);
+        let total = h * 3600 + m * 60;
+        (h <= 18 && m < 60 && total <= 18 * 3600).then(|| Self(sign * total))
+    }
+}
+
 /// Days since 1970-01-01 of a proleptic Gregorian date, or `None` for an
 /// invalid month/day (Howard Hinnant's `days_from_civil`).
 pub(crate) fn days_from_civil(year: i64, month: u32, day: u32) -> Option<i64> {
@@ -143,6 +179,42 @@ pub(crate) fn utc_to_local(utc: i64, tz: &dyn TimeZoneRules) -> Option<i64> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn session_zones_parse_as_fixed_offsets_or_none() {
+        for (zone, offset) in [
+            ("UTC", Some(0)),
+            (" GMT ", Some(0)),
+            ("Z", Some(0)),
+            ("Etc/UTC", Some(0)),
+            ("+05:30", Some(19_800)),
+            ("UTC-08:00", Some(-28_800)),
+            ("GMT+1", Some(3600)),
+            ("-18:00", Some(-64_800)),
+            ("+18:00", Some(64_800)),
+        ] {
+            assert_eq!(FixedOffset::parse(zone), offset.map(FixedOffset), "{zone}");
+        }
+        // Region ids need the tz database; malformed or out-of-range
+        // offsets are not zones.
+        for zone in [
+            "America/Los_Angeles",
+            "",
+            "+19:00",
+            "+05:60",
+            "+ab",
+            "UTC*1",
+            "++5",
+            "+05:+30",
+            "+18:30",
+            "+18:01",
+            "-18:30",
+            "+5:30:00",
+            "+",
+        ] {
+            assert_eq!(FixedOffset::parse(zone), None, "{zone}");
+        }
+    }
+
     #[test]
     fn civil_round_trips_and_spark_values() {
         // Values recorded from Spark 4.2 (`unix_date`).
diff --git a/crates/krishiv-kernels/src/cast/timestamp.rs b/crates/krishiv-kernels/src/cast/timestamp.rs
index 3b4a186c..a80efb03 100644
--- a/crates/krishiv-kernels/src/cast/timestamp.rs
+++ b/crates/krishiv-kernels/src/cast/timestamp.rs
@@ -67,6 +67,17 @@ pub fn timestamp_text(s: &str) -> TimestampText {
     }
 }
 
+/// Whether `s` names an explicit zone (an offset or region id after the
+/// seconds), as the cast kernel's parse sees it. Session-independent
+/// timestamp strings evaluate the same in every session zone.
+#[must_use]
+pub fn timestamp_has_zone(s: &str) -> bool {
+    matches!(
+        parse(s.as_bytes()),
+        Parsed::At(_, Zone::Offset(_) | Zone::Region)
+    )
+}
+
 /// Parses one string.
 pub(crate) fn parse(s: &[u8]) -> Parsed {
     let s = trim_all(s);
diff --git a/crates/krishiv-plan/src/analyzer/exprs.rs b/crates/krishiv-plan/src/analyzer/exprs.rs
index 0352b038..c663d8c8 100644
--- a/crates/krishiv-plan/src/analyzer/exprs.rs
+++ b/crates/krishiv-plan/src/analyzer/exprs.rs
@@ -30,6 +30,7 @@ use super::{AnalysisError, ArgType, CallTypes, Constant, FunctionEntry, Function
 use crate::{
     AttrId, BoundColumn, Builtin, CastMode, ColumnRef, Expr, ExprNode, FunctionCall, FunctionId,
     FunctionKind, Literal, LogicalPlan, Origin, ResolvedExpr, ResolvedFunction, Star, SubqueryKind,
+    TypedLiteralKind,
 };
 
 /// Where an operator's expressions resolve.
@@ -263,13 +264,14 @@ fn bad_cast(
     arg: &Bound,
     to: &DataType,
     mode: CastMode,
+    zone: Option<i32>,
 ) -> AnalysisError {
     let shown = ExprNode::Cast {
         expr: arg.shown(),
         to: to.clone(),
         mode,
     };
-    let sql_expr = format!("\"{}\"", pretty(&Expr::new(shown)));
+    let sql_expr = format!("\"{}\"", pretty(&Expr::new(shown), zone));
     let src_type = quoted_type(arg.ty.data_type.as_ref());
     let target_type = quoted_type(Some(to));
     let error: KrishivError = match bad {
@@ -350,6 +352,191 @@ pub(super) fn literal_type(v: &Literal) -> Option<DataType> {
     })
 }
 
+/// A typed datetime literal as Spark's `AstBuilder` builds it: the same
+/// `CAST('...' AS TIMESTAMP)` kernels execution uses, evaluated here with
+/// the session's resolved time zone and timestamp type. Plain `TIMESTAMP`
+/// means `TIMESTAMP_NTZ` when `spark.sql.timestampType = TIMESTAMP_NTZ`
+/// and the value names no zone, else an instant. Values needing the query
+/// clock (`now`, `today`, a bare time of day) or the time-zone database
+/// (a region id in the value, or a region session zone for a value
+/// without a zone) are `KRISHIV_UNSUPPORTED_FEATURE`, as the kernels
+/// report them.
+///
+/// # Errors
+/// `INVALID_TYPED_LITERAL` for text the type does not read, at the
+/// literal's origin; `KRISHIV_UNSUPPORTED_FEATURE` for clock- or
+/// time-zone-dependent values.
+fn typed_literal(
+    kind: TypedLiteralKind,
+    value: &str,
+    conf: &super::ResolutionConf,
+    origin: Origin,
+) -> Result<Literal, AnalysisError> {
+    use krishiv_common::error::{ErrorClass, InvalidTypedLiteral, KrishivUnsupportedFeature};
+    use krishiv_kernels::cast::{
+        CastMode as KernelMode, CastOptions, FixedOffset, TimestampText, cast, timestamp_has_zone,
+        timestamp_text,
+    };
+    let invalid = |value_type: &str| {
+        AnalysisError::new(
+            InvalidTypedLiteral {
+                value: format!("'{value}'"),
+                value_type: format!("\"{value_type}\""),
+            },
+            origin,
+        )
+    };
+    let unsupported = |feature: &str| {
+        AnalysisError::new(
+            KrishivUnsupportedFeature {
+                feature: feature.to_owned(),
+            },
+            origin,
+        )
+    };
+    let type_name = match kind {
+        TypedLiteralKind::Date => "DATE",
+        TypedLiteralKind::Timestamp => "TIMESTAMP",
+        TypedLiteralKind::TimestampNtz => "TIMESTAMP_NTZ",
+        TypedLiteralKind::TimestampLtz => "TIMESTAMP_LTZ",
+    };
+    // Clock-dependent spellings evaluate with the query clock, which the
+    // analyzer has not got.
+    if is_special(value) {
+        return Err(unsupported(
+            "a timestamp literal that needs the query clock",
+        ));
+    }
+    let shape = timestamp_text(value);
+    // A `DATE` is checked by its own cast below: the timestamp grammar
+    // rejects dates whose instant is past the microsecond range
+    // (`DATE '999999-03-18'`, valid in Spark), so only a bare time of day
+    // is read from the timestamp shape for it.
+    if shape == TimestampText::Malformed && kind != TypedLiteralKind::Date {
+        return Err(invalid(type_name));
+    }
+    // A bare time of day is valid only for an instant type, and needs the
+    // clock there too.
+    if shape == TimestampText::TimeOnly {
+        let without_zone = kind == TypedLiteralKind::Date
+            || kind == TypedLiteralKind::TimestampNtz
+            || (kind == TypedLiteralKind::Timestamp && conf.timestamp_ntz);
+        if without_zone {
+            return Err(invalid(type_name));
+        }
+        return Err(unsupported(
+            "a timestamp literal that needs the query clock",
+        ));
+    }
+    // One string cast through the kernels, as a microsecond instant or
+    // NTZ wall-clock value.
+    let cast_one = |value: &str, to: &arrow_schema::DataType, zone: &FixedOffset| {
+        use arrow_array::StringArray;
+        use arrow_array::cast::AsArray as _;
+        use arrow_array::types::TimestampMicrosecondType;
+        let input = StringArray::from(vec![value]);
+        let opts = CastOptions {
+            mode: KernelMode::Ansi,
+            time_zone: zone,
+        };
+        let out = cast(&input, to, &opts).map_err(KrishivError::from)?;
+        if out.is_null(0) {
+            // ANSI casts raise rather than null malformed input; a NULL
+            // here is unreachable.
+            return Err(KrishivError::from(KrishivUnsupportedFeature {
+                feature: "a timestamp literal".to_owned(),
+            }));
+        }
+        Ok(out.as_primitive::<TimestampMicrosecondType>().value(0))
+    };
+    let ltz_arrow = || {
+        arrow_schema::DataType::Timestamp(arrow_schema::TimeUnit::Microsecond, Some("UTC".into()))
+    };
+    let ntz_arrow = || arrow_schema::DataType::Timestamp(arrow_schema::TimeUnit::Microsecond, None);
+    let map_error = |e: KrishivError| {
+        if e.error_class() == ErrorClass::KrishivUnsupportedFeature {
+            AnalysisError::new(e, origin)
+        } else {
+            invalid(type_name)
+        }
+    };
+    match kind {
+        TypedLiteralKind::Date => {
+            use arrow_array::cast::AsArray as _;
+            use arrow_array::types::Date32Type;
+            let input = arrow_array::StringArray::from(vec![value]);
+            let opts = CastOptions {
+                mode: KernelMode::Ansi,
+                time_zone: &FixedOffset(0),
+            };
+            let out = cast(&input, &arrow_schema::DataType::Date32, &opts)
+                .map_err(|e| map_error(KrishivError::from(e)))?;
+            if out.is_null(0) {
+                return Err(invalid(type_name));
+            }
+            Ok(Literal::Date(out.as_primitive::<Date32Type>().value(0)))
+        }
+        TypedLiteralKind::TimestampNtz => {
+            let micros = cast_one(value, &ntz_arrow(), &FixedOffset(0)).map_err(map_error)?;
+            Ok(Literal::TimestampNtz(micros))
+        }
+        TypedLiteralKind::TimestampLtz => {
+            // Session-independent values (an explicit zone) evaluate under
+            // any zone; only session-dependent ones read the session zone.
+            if timestamp_has_zone(value) {
+                let micros = cast_one(value, &ltz_arrow(), &FixedOffset(0)).map_err(map_error)?;
+                Ok(Literal::Timestamp(micros))
+            } else {
+                match conf.session_zone {
+                    Some(off) => {
+                        let micros =
+                            cast_one(value, &ltz_arrow(), &FixedOffset(off)).map_err(map_error)?;
+                        Ok(Literal::Timestamp(micros))
+                    }
+                    None => Err(unsupported(
+                        "a timestamp literal in a session time zone other than a fixed offset",
+                    )),
+                }
+            }
+        }
+        TypedLiteralKind::Timestamp if conf.timestamp_ntz => {
+            // Under `TIMESTAMP_NTZ`, a value naming a zone is still an
+            // instant; without one it is wall-clock time.
+            if timestamp_has_zone(value) {
+                let micros = cast_one(value, &ltz_arrow(), &FixedOffset(0)).map_err(map_error)?;
+                Ok(Literal::Timestamp(micros))
+            } else {
+                let micros = cast_one(value, &ntz_arrow(), &FixedOffset(0)).map_err(map_error)?;
+                Ok(Literal::TimestampNtz(micros))
+            }
+        }
+        TypedLiteralKind::Timestamp => {
+            if timestamp_has_zone(value) {
+                let micros = cast_one(value, &ltz_arrow(), &FixedOffset(0)).map_err(map_error)?;
+                Ok(Literal::Timestamp(micros))
+            } else {
+                match conf.session_zone {
+                    Some(off) => {
+                        let micros =
+                            cast_one(value, &ltz_arrow(), &FixedOffset(off)).map_err(map_error)?;
+                        Ok(Literal::Timestamp(micros))
+                    }
+                    None => Err(unsupported(
+                        "a timestamp literal in a session time zone other than a fixed offset",
+                    )),
+                }
+            }
+        }
+    }
+}
+
+/// Whether `value` is one of Spark's special date/timestamp spellings
+/// (`now`, `today`, ...), which depend on the session's clock and zone.
+fn is_special(value: &str) -> bool {
+    let v = value.trim().to_ascii_lowercase();
+    ["epoch", "now", "today", "yesterday", "tomorrow"].contains(&v.as_str())
+}
+
 /// Where a node is bound: inside an aggregate call's arguments (`agg`),
 /// and whether it is the function of a window expression (`window_fn`:
 /// `sum(x)` in `sum(x) OVER w` is a window aggregate, not an aggregate of
@@ -573,6 +760,20 @@ impl Resolver<'_> {
                 nullable: matches!(v, Literal::Null(_)),
                 data_type: literal_type(v),
             }),
+            ExprNode::TypedLiteral { kind, value } => {
+                let literal = typed_literal(*kind, value, &self.ctx.conf, e.origin)?;
+                let ty = ArgType {
+                    nullable: false,
+                    data_type: literal_type(&literal),
+                };
+                // Shown as the resolved literal: Spark's names show the
+                // normalized value (`TIMESTAMP '2016-03-11 20:54:00'` for
+                // `.000`), formatted in the session zone by `pretty`.
+                Bound {
+                    expr: Arc::new(Expr::new(ExprNode::Literal(literal)).with_origin(e.origin)),
+                    ..keep(ty)
+                }
+            }
             ExprNode::Star(_) => {
                 return Err(AnalysisError::new(
                     InvalidUsageOfStarOrRegex {
@@ -589,7 +790,10 @@ impl Resolver<'_> {
                 {
                     return Err(AnalysisError::new(
                         InvalidAggregateFilterNotBoolean {
-                            filter_expr: format!("\"{}\"", pretty(&filter.shown())),
+                            filter_expr: format!(
+                                "\"{}\"",
+                                pretty(&filter.shown(), self.ctx.conf.session_zone)
+                            ),
                         },
                         e.origin,
                     ));
@@ -661,7 +865,14 @@ impl Resolver<'_> {
                 };
                 let child = &kids[0].ty;
                 if let Err(bad) = coerce::can_cast(child.data_type.as_ref(), to, mode) {
-                    return Err(bad_cast(bad, e.origin, &kids[0], to, mode));
+                    return Err(bad_cast(
+                        bad,
+                        e.origin,
+                        &kids[0],
+                        to,
+                        mode,
+                        self.ctx.conf.session_zone,
+                    ));
                 }
                 let nullable = child.nullable
                     || child.data_type.as_ref().is_some_and(|from| {
@@ -780,7 +991,8 @@ impl Resolver<'_> {
             .collect();
         let literals: Vec<bool> = kids.iter().map(|k| fold::is_literal(&k.expr)).collect();
         // Rendered only if a rule's error quotes an argument.
-        let sql = |i: usize| kids.get(i).map(|k| pretty(&k.shown()));
+        let zone = self.ctx.conf.session_zone;
+        let sql = |i: usize| kids.get(i).map(|k| pretty(&k.shown(), zone));
         let given: Vec<ArgType> = kids.iter().map(|k| k.ty.clone()).collect();
         let ansi = self.ctx.conf.ansi;
         let loss = self.ctx.conf.decimal_precision_loss;
@@ -1258,7 +1470,8 @@ impl Resolver<'_> {
         cx: &Cx<'_>,
     ) -> Result<(Vec<Bound>, Arc<LogicalPlan>), AnalysisError> {
         let shown = with_children(e, kids.iter().map(Bound::shown).collect());
-        let sql_expr = format!("\"{}\"", pretty(&shown));
+        let zone = self.ctx.conf.session_zone;
+        let sql_expr = format!("\"{}\"", pretty(&shown, zone));
         let texts = |v: Vec<String>| v.join(", ");
         if kids.len() != rel.out.len() {
             return Err(AnalysisError::new(
@@ -1267,7 +1480,7 @@ impl Resolver<'_> {
                     left_length: kids.len().to_string(),
                     left_columns: texts(
                         kids.iter()
-                            .map(|k| format!("\"{}\"", pretty(&k.shown())))
+                            .map(|k| format!("\"{}\"", pretty(&k.shown(), zone)))
                             .collect(),
                     ),
                     right_length: rel.out.len().to_string(),
@@ -1300,7 +1513,10 @@ impl Resolver<'_> {
                 None => {
                     let left = format!(
                         "{}:{}",
-                        pretty(&super::ops::qualified(&k.shown(), cx.scope)),
+                        pretty(
+                            &super::ops::qualified(&k.shown(), cx.scope),
+                            self.ctx.conf.session_zone
+                        ),
                         k.ty.data_type
                             .as_ref()
                             .map_or_else(|| "void".to_owned(), DataType::simple_string)
@@ -1391,7 +1607,8 @@ impl Resolver<'_> {
         function: &str,
         origin: Origin,
     ) -> AnalysisError {
-        let sql_expr = format!("\"{}\"", pretty(call));
+        let zone = self.ctx.conf.session_zone;
+        let sql_expr = format!("\"{}\"", pretty(call, zone));
         let error: KrishivError = match m {
             Mismatch::DiffTypes(left, right) => DatatypeMismatchBinaryOpDiffTypes {
                 sql_expr,
@@ -1417,7 +1634,9 @@ impl Resolver<'_> {
                     Some(name) if param == 1 => (
                         format!(
                             "\"{name}({})\"",
-                            kids.get(1).map(|k| pretty(&k.shown())).unwrap_or_default()
+                            kids.get(1)
+                                .map(|k| pretty(&k.shown(), zone))
+                                .unwrap_or_default()
                         ),
                         0,
                     ),
@@ -1430,7 +1649,7 @@ impl Resolver<'_> {
                     input_sql: format!(
                         "\"{}\"",
                         kids.get(arg)
-                            .map(|k| pretty(&k.shown()))
+                            .map(|k| pretty(&k.shown(), zone))
                             .unwrap_or_default()
                     ),
                     input_type: quoted_type(ty.as_ref()),
@@ -1857,8 +2076,10 @@ fn builtin_op(name: &str, arity: usize) -> Option<crate::Builtin> {
 
 /// Spark's generated name for an unaliased expression (`toPrettySQL`):
 /// `(a + 1)`, `count(1)`, `CASE WHEN ... END`. Built bottom-up with an
-/// explicit stack, once per distinct node.
-pub(super) fn pretty(e: &Expr) -> String {
+/// explicit stack, once per distinct node. Timestamp literals render in
+/// `zone`, the session's resolved zone, through the same cast-to-string
+/// kernels `CAST(ts AS STRING)` uses.
+pub(super) fn pretty(e: &Expr, zone: Option<i32>) -> String {
     let mut done: HashMap<usize, String> = HashMap::new();
     let mut stack = vec![(e, false)];
     while let Some((x, expanded)) = stack.pop() {
@@ -1876,7 +2097,7 @@ pub(super) fn pretty(e: &Expr) -> String {
             .iter()
             .map(|c| done.get(&addr(*c)).map_or("", String::as_str))
             .collect();
-        let mut s = pretty_node(x, &k);
+        let mut s = pretty_node(x, &k, zone);
         if s.len() > MAX_NAME {
             // A shared subexpression repeated in a name doubles it per level:
             // names stay bounded (Spark's would not).
@@ -1913,13 +2134,22 @@ fn outer_names(plan: &crate::LogicalPlan) -> String {
         .join(", ")
 }
 
-fn pretty_node(x: &Expr, k: &[&str]) -> String {
+fn pretty_node(x: &Expr, k: &[&str], zone: Option<i32>) -> String {
     match &x.node {
         ExprNode::Resolved(ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c)) => {
             c.name.clone()
         }
         ExprNode::Column(c) => c.name.last().cloned().unwrap_or_default(),
-        ExprNode::Literal(v) => pretty_literal(v),
+        ExprNode::Literal(v) => pretty_literal(v, zone),
+        ExprNode::TypedLiteral { kind, value } => {
+            let keyword = match kind {
+                TypedLiteralKind::Date => "DATE",
+                TypedLiteralKind::Timestamp => "TIMESTAMP",
+                TypedLiteralKind::TimestampNtz => "TIMESTAMP_NTZ",
+                TypedLiteralKind::TimestampLtz => "TIMESTAMP_LTZ",
+            };
+            format!("{keyword} '{value}'")
+        }
         ExprNode::Cast { to, mode, .. } => {
             let cast = if *mode == CastMode::Try {
                 "TRY_CAST"
@@ -1948,7 +2178,7 @@ fn pretty_node(x: &Expr, k: &[&str]) -> String {
             }
         }
         ExprNode::Star(_) => "*".to_owned(),
-        ExprNode::Window(w) => pretty_window(w, k),
+        ExprNode::Window(w) => pretty_window(w, k, zone),
         ExprNode::Function(FunctionCall { name, distinct, .. }) => {
             call(name, Builtin::from_name(name), *distinct, k, None)
         }
@@ -1971,7 +2201,7 @@ fn pretty_node(x: &Expr, k: &[&str]) -> String {
 /// `DENSE_RANK()` and `PERCENT_RANK()` upper case, as Spark's `RankLike`
 /// writes them), then the window as `WindowSpecDefinition.sql` writes it.
 /// `k` holds the children's names in [`Expr::for_each_child`] order.
-fn pretty_window(w: &crate::WindowExpr, k: &[&str]) -> String {
+fn pretty_window(w: &crate::WindowExpr, k: &[&str], zone: Option<i32>) -> String {
     use crate::{FrameBound, FrameUnits, WindowSpecRef};
     let function = match &w.function.node {
         ExprNode::Resolved(ResolvedExpr::Function(f))
@@ -2018,7 +2248,7 @@ fn pretty_window(w: &crate::WindowExpr, k: &[&str]) -> String {
             FrameBound::Offset(e) => {
                 let own = rest.next().copied().unwrap_or_default();
                 match crate::expr::negated(e) {
-                    Some(n) => format!("{} PRECEDING", pretty(n)),
+                    Some(n) => format!("{} PRECEDING", pretty(n, zone)),
                     None => format!("{own} FOLLOWING"),
                 }
             }
@@ -2236,7 +2466,7 @@ fn is_upper_math(name: &str) -> bool {
     )
 }
 
-fn pretty_literal(v: &Literal) -> String {
+fn pretty_literal(v: &Literal, zone: Option<i32>) -> String {
     match v {
         // A URL's credentials never reach a name (ADR 0038).
         Literal::String(s) => krishiv_common::secret::SecretUrl::parse(s)
@@ -2265,7 +2495,12 @@ fn pretty_literal(v: &Literal) -> String {
             out
         }
         Literal::Date(days) => crate::spark_fmt::date(*days),
-        Literal::Timestamp(us) => crate::spark_fmt::timestamp(*us, false),
+        // An instant renders in the session zone (a fixed offset; UTC when
+        // unset), as Spark's `toPrettySQL` of a timestamp literal does.
+        Literal::Timestamp(us) => crate::spark_fmt::timestamp(
+            us.saturating_add(i64::from(zone.unwrap_or(0)).saturating_mul(1_000_000)),
+            false,
+        ),
         Literal::TimestampNtz(us) => crate::spark_fmt::timestamp(*us, true),
         _ => v.to_string(),
     }
diff --git a/crates/krishiv-plan/src/analyzer/hints.rs b/crates/krishiv-plan/src/analyzer/hints.rs
index a6864032..ce060916 100644
--- a/crates/krishiv-plan/src/analyzer/hints.rs
+++ b/crates/krishiv-plan/src/analyzer/hints.rs
@@ -250,7 +250,7 @@ fn shown(e: &Expr) -> String {
     match &e.node {
         ExprNode::Column(c) => c.name.join("."),
         ExprNode::Literal(Literal::String(s)) => format!("'{s}'"),
-        _ => pretty(e),
+        _ => pretty(e, None),
     }
 }
 
@@ -263,7 +263,7 @@ fn bad_parameter(e: &Expr) -> AnalysisError {
     };
     AnalysisError::new(
         LegacyErrorTemp1046 {
-            unsupported: format!("\"{}\"", pretty(e)),
+            unsupported: format!("\"{}\"", pretty(e, None)),
             class: format!("class {class}"),
         },
         e.origin,
diff --git a/crates/krishiv-plan/src/analyzer/mod.rs b/crates/krishiv-plan/src/analyzer/mod.rs
index 01aa3969..1422f2b7 100644
--- a/crates/krishiv-plan/src/analyzer/mod.rs
+++ b/crates/krishiv-plan/src/analyzer/mod.rs
@@ -124,6 +124,15 @@ pub struct ResolutionConf {
     pub decimal_precision_loss: bool,
     /// `spark.sql.runSQLOnFiles`: `` format.`path` `` reads files.
     pub run_sql_on_files: bool,
+    /// `spark.sql.timestampType = TIMESTAMP_NTZ`: plain `TIMESTAMP '...'`
+    /// without a zone is a `TIMESTAMP_NTZ`.
+    pub timestamp_ntz: bool,
+    /// `spark.sql.session.timeZone` as a fixed offset in seconds east of
+    /// UTC (`UTC` is `Some(0)`); `None` for a region id or a malformed
+    /// zone, which need the time-zone database. Unset is `Some(0)`, the
+    /// default the cast path uses, so the default session resolves
+    /// timestamp literals.
+    pub session_zone: Option<i32>,
 }
 
 impl Default for ResolutionConf {
@@ -138,13 +147,15 @@ impl Default for ResolutionConf {
             lateral_column_alias: true,
             decimal_precision_loss: true,
             run_sql_on_files: true,
+            timestamp_ntz: false,
+            session_zone: Some(0),
         }
     }
 }
 
 impl ResolutionConf {
     /// The session configs [`Self::from_conf`] reads: the only ones.
-    pub const KEYS: [&'static str; 8] = [
+    pub const KEYS: [&'static str; 10] = [
         "spark.sql.caseSensitive",
         "spark.sql.ansi.enabled",
         "spark.sql.groupByAliases",
@@ -153,6 +164,8 @@ impl ResolutionConf {
         "spark.sql.lateralColumnAlias.enableImplicitResolution",
         "spark.sql.decimalOperations.allowPrecisionLoss",
         "spark.sql.runSQLOnFiles",
+        "spark.sql.timestampType",
+        "spark.sql.session.timeZone",
     ];
 
     /// The flags from session configs; `conf` returns a config's value if
@@ -170,7 +183,7 @@ impl ResolutionConf {
             d.run_sql_on_files,
         ];
         let mut v = [false; 8];
-        for ((slot, key), default) in v.iter_mut().zip(Self::KEYS).zip(defaults) {
+        for ((slot, key), default) in v.iter_mut().zip(Self::KEYS[..8].iter()).zip(defaults) {
             *slot = conf(key).map_or(default, |s| s.trim().eq_ignore_ascii_case("true"));
         }
         Self {
@@ -182,6 +195,12 @@ impl ResolutionConf {
             lateral_column_alias: v[5],
             decimal_precision_loss: v[6],
             run_sql_on_files: v[7],
+            timestamp_ntz: conf(Self::KEYS[8])
+                .is_some_and(|s| s.trim().eq_ignore_ascii_case("TIMESTAMP_NTZ")),
+            session_zone: match conf(Self::KEYS[9]) {
+                None => Some(0),
+                Some(s) => krishiv_kernels::cast::FixedOffset::parse(s).map(|o| o.0),
+            },
         }
     }
 }
@@ -258,12 +277,21 @@ impl ContextFingerprint {
             c.lateral_column_alias,
             c.decimal_precision_loss,
             c.run_sql_on_files,
+            c.timestamp_ntz,
             self.files,
         ];
         num(
             &mut b,
             flags.iter().fold(0, |acc, f| acc << 1 | u64::from(*f)),
         );
+        // The session zone: `None` (a region id) is one input.
+        num(
+            &mut b,
+            match c.session_zone {
+                Some(v) => u64::from(u32::from_ne_bytes(v.to_ne_bytes())),
+                None => 0x8000_0000,
+            },
+        );
         num(&mut b, self.current.len() as u64);
         self.current.iter().for_each(|p| text(&mut b, p));
         num(&mut b, self.catalogs);
diff --git a/crates/krishiv-plan/src/analyzer/ops.rs b/crates/krishiv-plan/src/analyzer/ops.rs
index a16b3121..f48cc5d7 100644
--- a/crates/krishiv-plan/src/analyzer/ops.rs
+++ b/crates/krishiv-plan/src/analyzer/ops.rs
@@ -319,13 +319,14 @@ impl Resolver<'_> {
             return Ok(b);
         }
         let shown = b.shown();
+        let zone = self.ctx.conf.session_zone;
         let name = match &shown.node {
             ExprNode::Cast { expr, .. }
                 if matches!(expr.node, ExprNode::Resolved(ResolvedExpr::Column(_))) =>
             {
-                pretty(expr)
+                pretty(expr, zone)
             }
-            _ => pretty(&lateral_refs(&shown, &b.lateral)),
+            _ => pretty(&lateral_refs(&shown, &b.lateral), zone),
         };
         let output = self.attr(&name, &b.ty);
         let origin = b.expr.origin;
@@ -475,7 +476,7 @@ impl Resolver<'_> {
         if b.agg.is_some() {
             return Err(AnalysisError::new(
                 InvalidWhereCondition {
-                    condition: format!("\"{}\"", pretty(&b.shown())),
+                    condition: format!("\"{}\"", pretty(&b.shown(), self.ctx.conf.session_zone)),
                     expression_list: aggregate_sql(&b.expr, &wide.out),
                 },
                 p.origin,
@@ -796,7 +797,7 @@ impl Resolver<'_> {
                                 data_type: Some(f.data_type.clone()),
                                 nullable: f.nullable,
                             };
-                            let output = self.attr(&pretty(&x), &ty);
+                            let output = self.attr(&pretty(&x, self.ctx.conf.session_zone), &ty);
                             grown.aggregates.push(Arc::new(Expr::new(ExprNode::Resolved(
                                 ResolvedExpr::Alias {
                                     expr: Arc::clone(&x),
@@ -917,7 +918,7 @@ impl Resolver<'_> {
                 let a = match st.known.iter().find(|(k, _)| *k == key) {
                     Some((_, a)) => a.clone(),
                     None => {
-                        let output = self.attr(&pretty(&b.expr), &b.ty);
+                        let output = self.attr(&pretty(&b.expr, self.ctx.conf.session_zone), &b.ty);
                         st.grown
                             .aggregates
                             .push(Arc::new(Expr::new(ExprNode::Resolved(
@@ -1075,7 +1076,7 @@ impl Resolver<'_> {
             if has_aggregate(&b.expr) {
                 return Err(AnalysisError::new(
                     GroupByAggregate {
-                        sql_expr: pretty(&b.expr),
+                        sql_expr: pretty(&b.expr, self.ctx.conf.session_zone),
                     },
                     b.expr.origin,
                 ));
@@ -1124,7 +1125,7 @@ impl Resolver<'_> {
         if let (Some(_), ExprNode::Resolved(ResolvedExpr::Alias { expr, output })) =
             (item.agg, &item.expr.node)
         {
-            let text = pretty(&qualified(expr, &c.out));
+            let text = pretty(&qualified(expr, &c.out), self.ctx.conf.session_zone);
             return Err(AnalysisError::new(
                 GroupByPosAggregate {
                     index: n.to_string(),
@@ -1275,7 +1276,7 @@ impl Resolver<'_> {
                 return Err(AnalysisError::new(MissingGroupBy {}, l.origin));
             }
             (None, ExprNode::Resolved(ResolvedExpr::Column(_))) => {
-                let text = pretty(&x);
+                let text = pretty(&x, self.ctx.conf.session_zone);
                 return Err(AnalysisError::new(
                     MissingAggregation {
                         expression: format!("\"{text}\""),
@@ -1308,7 +1309,7 @@ impl Resolver<'_> {
                 a
             }
             (None, None) => {
-                let output = self.attr(&pretty(&x), &ty);
+                let output = self.attr(&pretty(&x, self.ctx.conf.session_zone), &ty);
                 info.aggregates.push(Arc::new(Expr::new(ExprNode::Resolved(
                     ResolvedExpr::Alias {
                         expr: Arc::clone(&x),
@@ -1352,7 +1353,7 @@ impl Resolver<'_> {
                         return Err(AnalysisError::new(MissingGroupBy {}, origin));
                     }
                     ExprNode::Resolved(ResolvedExpr::Column(_)) => {
-                        let text = pretty(&x);
+                        let text = pretty(&x, self.ctx.conf.session_zone);
                         return Err(AnalysisError::new(
                             MissingAggregation {
                                 expression: format!("\"{text}\""),
@@ -1415,7 +1416,10 @@ impl Resolver<'_> {
                 if b.ty.data_type != Some(krishiv_types::DataType::Boolean) {
                     return Err(AnalysisError::new(
                         JoinConditionIsNotBooleanType {
-                            join_condition: format!("\"{}\"", pretty(&b.shown())),
+                            join_condition: format!(
+                                "\"{}\"",
+                                pretty(&b.shown(), self.ctx.conf.session_zone)
+                            ),
                             condition_type: quoted_type(b.ty.data_type.as_ref()),
                         },
                         p.origin,
@@ -1654,7 +1658,7 @@ impl Resolver<'_> {
         if !unfoldable && b.ty.data_type != Some(krishiv_types::DataType::Integer) {
             return Err(AnalysisError::new(
                 InvalidLimitLikeExpressionDataType {
-                    expr: format!("\"{}\"", pretty(&b.shown())),
+                    expr: format!("\"{}\"", pretty(&b.shown(), self.ctx.conf.session_zone)),
                     name: name.to_owned(),
                     data_type: quoted_type(b.ty.data_type.as_ref()),
                 },
@@ -1868,7 +1872,7 @@ fn out_attr(b: &Bound, scope: &[Attr]) -> Attr {
         _ => Attr {
             col: BoundColumn {
                 id: AttrId(u64::MAX),
-                name: pretty(&b.expr),
+                name: pretty(&b.expr, None),
                 data_type: krishiv_types::DataType::Boolean,
                 nullable: true,
             },
@@ -1883,7 +1887,7 @@ pub(super) fn boolean_filter(b: &Bound, origin: Origin) -> Result<(), AnalysisEr
     if b.ty.data_type == Some(krishiv_types::DataType::Boolean) {
         return Ok(());
     }
-    let text = format!("\"{}\"", pretty(&b.shown()));
+    let text = format!("\"{}\"", pretty(&b.shown(), None));
     Err(AnalysisError::new(
         DatatypeMismatchFilterNotBoolean {
             sql_expr: text.clone(),
@@ -1993,7 +1997,10 @@ fn in_aggregate_call(b: &Bound) -> Result<(), AnalysisError> {
                 {
                     return Err(AnalysisError::new(
                         UnsupportedFeatureLateralColumnAliasInAggregateFunc {
-                            agg_func: format!("\"{}\"", pretty(&lateral_refs(&x, &b.lateral))),
+                            agg_func: format!(
+                                "\"{}\"",
+                                pretty(&lateral_refs(&x, &b.lateral), None)
+                            ),
                             lca: quoted(std::slice::from_ref(&c.name)),
                         },
                         Origin::UNKNOWN,
@@ -2021,7 +2028,7 @@ fn aggregate_sql(e: &Arc<Expr>, scope: &[Attr]) -> String {
         if let ExprNode::Resolved(ResolvedExpr::Function(f)) = &x.node
             && f.kind == FunctionKind::Aggregate
         {
-            found.push(pretty(&qualified(&x, scope)));
+            found.push(pretty(&qualified(&x, scope), None));
             continue;
         }
         x.for_each_child(&mut |k| stack.push(Arc::clone(k)));
diff --git a/crates/krishiv-plan/src/analyzer/resolve.rs b/crates/krishiv-plan/src/analyzer/resolve.rs
index 1b31c243..9f554889 100644
--- a/crates/krishiv-plan/src/analyzer/resolve.rs
+++ b/crates/krishiv-plan/src/analyzer/resolve.rs
@@ -497,7 +497,10 @@ impl Resolver<'_> {
         let text = if nondeterministic {
             "\"_nondeterministic\"".to_owned()
         } else {
-            format!("\"{}\"", super::exprs::pretty(&b.shown()))
+            format!(
+                "\"{}\"",
+                super::exprs::pretty(&b.shown(), self.ctx.conf.session_zone)
+            )
         };
         let name = name.to_owned();
         let folded = if unfoldable {
diff --git a/crates/krishiv-plan/src/analyzer/setops.rs b/crates/krishiv-plan/src/analyzer/setops.rs
index 5b4c8ba3..93a5d74d 100644
--- a/crates/krishiv-plan/src/analyzer/setops.rs
+++ b/crates/krishiv-plan/src/analyzer/setops.rs
@@ -609,7 +609,7 @@ fn hint_value(e: &Expr) -> String {
         ExprNode::Literal(Literal::Short(n)) => n.to_string(),
         ExprNode::Literal(Literal::Integer(n)) => n.to_string(),
         ExprNode::Literal(Literal::Long(n)) => n.to_string(),
-        _ => super::exprs::pretty(e),
+        _ => super::exprs::pretty(e, None),
     }
 }
 
diff --git a/crates/krishiv-plan/src/analyzer/subquery.rs b/crates/krishiv-plan/src/analyzer/subquery.rs
index 4dffaa9e..42068610 100644
--- a/crates/krishiv-plan/src/analyzer/subquery.rs
+++ b/crates/krishiv-plan/src/analyzer/subquery.rs
@@ -613,7 +613,7 @@ impl Rewriter {
                             crate::NullOrdering::NullsFirst => "NULLS FIRST",
                             crate::NullOrdering::NullsLast => "NULLS LAST",
                         };
-                        format!("\"{} {dir} {nulls}\"", pretty(&o.expr))
+                        format!("\"{} {dir} {nulls}\"", pretty(&o.expr, None))
                     })
                     .collect();
                 if outer.is_empty() {
@@ -803,7 +803,7 @@ impl Rewriter {
                         .ok_or_else(|| unsupported("a correlation key of this form", k.origin))?;
                     let output = BoundColumn {
                         id: self.fresh(),
-                        name: pretty(k),
+                        name: pretty(k, None),
                         data_type,
                         nullable,
                     };
diff --git a/crates/krishiv-plan/src/analyzer/windows.rs b/crates/krishiv-plan/src/analyzer/windows.rs
index 0e87794b..97a60db0 100644
--- a/crates/krishiv-plan/src/analyzer/windows.rs
+++ b/crates/krishiv-plan/src/analyzer/windows.rs
@@ -66,7 +66,7 @@ pub(super) fn window_function_sql(name: &str, shown: &Expr) -> String {
     if RANK_LIKE.contains(&name) {
         format!("{}()", name.to_uppercase())
     } else {
-        pretty(shown)
+        pretty(shown, None)
     }
 }
 
@@ -87,10 +87,10 @@ pub(super) fn window_in_aggregate(origin: Origin) -> AnalysisError {
 
 /// `INVALID_AGGREGATE_FILTER.CONTAINS_WINDOW_FUNCTION` for `filter`.
 pub(super) fn window_in_filter(filter: &Bound, origin: Origin) -> AnalysisError {
-    let window = first_window(&filter.shown()).map_or_else(String::new, |w| pretty(&w));
+    let window = first_window(&filter.shown()).map_or_else(String::new, |w| pretty(&w, None));
     AnalysisError::new(
         InvalidAggregateFilterContainsWindowFunction {
-            filter_expr: format!("\"{}\"", pretty(&filter.shown())),
+            filter_expr: format!("\"{}\"", pretty(&filter.shown(), None)),
             window_expr: format!("\"{window}\""),
         },
         origin,
@@ -110,7 +110,7 @@ pub(super) fn misplaced(use_: WindowUse, b: &Bound, origin: Origin) -> AnalysisE
         WindowUse::Where => clause("WHERE"),
         WindowUse::Having => clause("HAVING"),
         WindowUse::Allowed | WindowUse::Other => {
-            let window = first_window(&b.shown()).map_or_else(String::new, |w| pretty(&w));
+            let window = first_window(&b.shown()).map_or_else(String::new, |w| pretty(&w, None));
             UnsupportedExprForOperator {
                 invalid_expr_sqls: format!("\"{window}\""),
             }
@@ -142,8 +142,8 @@ fn frame_string(f: &WindowFrame) -> String {
         FrameBound::CurrentRow => "currentrow$()".to_owned(),
         FrameBound::UnboundedFollowing => "unboundedfollowing$()".to_owned(),
         FrameBound::Offset(e) => match crate::expr::negated(e) {
-            Some(n) => format!("-{}", pretty(n)),
-            None => pretty(e),
+            Some(n) => format!("-{}", pretty(n, None)),
+            None => pretty(e, None),
         },
     };
     let units = match f.units {
@@ -164,8 +164,8 @@ fn bound_sql(b: &FrameBound) -> String {
         FrameBound::CurrentRow => "CURRENT ROW".to_owned(),
         FrameBound::UnboundedFollowing => "UNBOUNDED FOLLOWING".to_owned(),
         FrameBound::Offset(e) => match crate::expr::negated(e) {
-            Some(n) => format!("{} PRECEDING", pretty(n)),
-            None => format!("{} FOLLOWING", pretty(e)),
+            Some(n) => format!("{} PRECEDING", pretty(n, None)),
+            None => format!("{} FOLLOWING", pretty(e, None)),
         },
     };
     format!("\"{text}\"")
@@ -173,10 +173,13 @@ fn bound_sql(b: &FrameBound) -> String {
 
 /// Spark's text of `function OVER (spec)`, as its errors quote it.
 fn window_text(function: &Arc<Expr>, spec: &WindowSpec) -> String {
-    pretty(&Expr::new(ExprNode::Window(WindowExpr {
-        function: Arc::clone(function),
-        window: WindowSpecRef::Spec(spec.clone()),
-    })))
+    pretty(
+        &Expr::new(ExprNode::Window(WindowExpr {
+            function: Arc::clone(function),
+            window: WindowSpecRef::Spec(spec.clone()),
+        })),
+        None,
+    )
 }
 
 impl Resolver<'_> {
@@ -361,13 +364,16 @@ impl Resolver<'_> {
                 .map_or_else(String::new, |a| a.col.name.clone());
             let shown = shown_of(rest.iter().map(Bound::shown).collect());
             let ids: Vec<crate::AttrId> = kids.iter().flat_map(|k| k.lateral.clone()).collect();
-            let text = pretty(&super::ops::lateral_refs(
-                &Arc::new(Expr::new(ExprNode::Window(WindowExpr {
-                    function: function.shown(),
-                    window: WindowSpecRef::Spec(shown),
-                }))),
-                &ids,
-            ));
+            let text = pretty(
+                &super::ops::lateral_refs(
+                    &Arc::new(Expr::new(ExprNode::Window(WindowExpr {
+                        function: function.shown(),
+                        window: WindowSpecRef::Spec(shown),
+                    }))),
+                    &ids,
+                ),
+                None,
+            );
             return Err(AnalysisError::new(
                 UnsupportedFeatureLateralColumnAliasInWindow {
                     lca: format!("`{lca}`"),
@@ -385,7 +391,7 @@ impl Resolver<'_> {
             _ => {
                 return Err(AnalysisError::new(
                     UnsupportedExprForWindow {
-                        sql_expr: format!("\"{}\"", pretty(&function.shown())),
+                        sql_expr: format!("\"{}\"", pretty(&function.shown(), None)),
                     },
                     e.origin,
                 ));
diff --git a/crates/krishiv-plan/src/display.rs b/crates/krishiv-plan/src/display.rs
index fa0a76fd..0b9b2551 100644
--- a/crates/krishiv-plan/src/display.rs
+++ b/crates/krishiv-plan/src/display.rs
@@ -493,6 +493,15 @@ fn expr_pieces<'a>(e: &'a Expr, out: &mut Vec<Piece<'a>>) {
             out.push(Piece::Owned(format!("{}{id}", Name(&c.name))));
         }
         ExprNode::Literal(v) => out.push(Piece::Owned(literal_text(v))),
+        ExprNode::TypedLiteral { kind, value } => {
+            let keyword = match kind {
+                crate::TypedLiteralKind::Date => "DATE",
+                crate::TypedLiteralKind::Timestamp => "TIMESTAMP",
+                crate::TypedLiteralKind::TimestampNtz => "TIMESTAMP_NTZ",
+                crate::TypedLiteralKind::TimestampLtz => "TIMESTAMP_LTZ",
+            };
+            out.push(Piece::Owned(format!("{keyword} '{value}'")));
+        }
         ExprNode::Star(s) => {
             let q = if s.qualifier.is_empty() {
                 String::new()
diff --git a/crates/krishiv-plan/src/encode.rs b/crates/krishiv-plan/src/encode.rs
index d631170b..b5f032a8 100644
--- a/crates/krishiv-plan/src/encode.rs
+++ b/crates/krishiv-plan/src/encode.rs
@@ -1018,6 +1018,16 @@ impl<'k, 'a> Encoder<'k, 'a> {
                     }
                 }
             }
+            ExprNode::TypedLiteral { kind, value } => {
+                self.u8(13);
+                self.u8(match kind {
+                    crate::TypedLiteralKind::Date => 1,
+                    crate::TypedLiteralKind::Timestamp => 2,
+                    crate::TypedLiteralKind::TimestampNtz => 3,
+                    crate::TypedLiteralKind::TimestampLtz => 4,
+                });
+                self.str(value);
+            }
         }
     }
 
diff --git a/crates/krishiv-plan/src/expr.rs b/crates/krishiv-plan/src/expr.rs
index f314fd9b..b4223dd4 100644
--- a/crates/krishiv-plan/src/expr.rs
+++ b/crates/krishiv-plan/src/expr.rs
@@ -27,6 +27,22 @@ pub struct Expr {
     pub origin: Origin,
 }
 
+/// The kind of an unresolved typed datetime literal (`TIMESTAMP '...'`),
+/// as the parser wrote it. The analyzer resolves it to a [`Literal`]
+/// with the session's time zone and timestamp type.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum TypedLiteralKind {
+    /// `DATE '...'`.
+    Date,
+    /// `TIMESTAMP '...'`.
+    Timestamp,
+    /// `TIMESTAMP_NTZ '...'`.
+    TimestampNtz,
+    /// `TIMESTAMP_LTZ '...'`.
+    TimestampLtz,
+}
+
 /// The expression node kinds.
 ///
 /// Operators are [`ExprNode::Function`] calls with canonical names (see
@@ -39,6 +55,14 @@ pub enum ExprNode {
     Column(ColumnRef),
     /// A literal value.
     Literal(Literal),
+    /// An unresolved typed datetime literal: the type keyword and the raw
+    /// string, as written. The analyzer lowers it to a [`Literal`].
+    TypedLiteral {
+        /// Which type keyword was written.
+        kind: TypedLiteralKind,
+        /// The raw string, as written.
+        value: String,
+    },
     /// An unresolved `*` or `t.*`.
     Star(Star),
     /// An unresolved function call, operators included.
@@ -445,6 +469,7 @@ impl Expr {
         match &self.node {
             ExprNode::Column(_)
             | ExprNode::Literal(_)
+            | ExprNode::TypedLiteral { .. }
             | ExprNode::Star(_)
             | ExprNode::Resolved(ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_)) => {}
             ExprNode::Function(FunctionCall { args, filter, .. })
@@ -484,6 +509,7 @@ impl Expr {
         match &mut self.node {
             ExprNode::Column(_)
             | ExprNode::Literal(_)
+            | ExprNode::TypedLiteral { .. }
             | ExprNode::Star(_)
             | ExprNode::Resolved(ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_)) => {}
             ExprNode::Function(FunctionCall { args, filter, .. })
diff --git a/crates/krishiv-plan/src/lib.rs b/crates/krishiv-plan/src/lib.rs
index ee1f19ec..dbe5233a 100644
--- a/crates/krishiv-plan/src/lib.rs
+++ b/crates/krishiv-plan/src/lib.rs
@@ -121,7 +121,7 @@ pub use encode::{ENCODING_VERSION, StructuralHash};
 pub use expr::{
     AttrId, BoundColumn, CastMode, ColumnRef, Expr, ExprNode, FrameBound, FrameUnits, FunctionCall,
     NullOrdering, ResolvedExpr, ResolvedFunction, SortDirection, SortOrder, Star, SubqueryKind,
-    WindowExpr, WindowFrame, WindowSpec, WindowSpecRef,
+    TypedLiteralKind, WindowExpr, WindowFrame, WindowSpec, WindowSpecRef,
 };
 pub use function::{Builtin, FunctionId, FunctionKind};
 pub use literal::{DayTimeField, Literal, YearMonthField};
diff --git a/crates/krishiv-plan/src/tests/analyzer.rs b/crates/krishiv-plan/src/tests/analyzer.rs
index f8054965..0c8e03c9 100644
--- a/crates/krishiv-plan/src/tests/analyzer.rs
+++ b/crates/krishiv-plan/src/tests/analyzer.rs
@@ -1375,6 +1375,23 @@ fn resolution_reads_only_its_configs() {
         ResolutionConf::from_conf(|_| None),
         ResolutionConf::default()
     );
+    // The timestamp type and session zone flow through `from_conf`: unset
+    // is UTC, fixed offsets resolve, regions and malformed zones are `None`.
+    let ntz =
+        ResolutionConf::from_conf(|k| (k == "spark.sql.timestampType").then_some("TIMESTAMP_NTZ"));
+    assert!(ntz.timestamp_ntz);
+    assert_eq!(ntz.session_zone, Some(0));
+    let plus =
+        ResolutionConf::from_conf(|k| (k == "spark.sql.session.timeZone").then_some("+05:30"));
+    assert_eq!(plus.session_zone, Some(19_800));
+    assert!(!plus.timestamp_ntz);
+    let region = ResolutionConf::from_conf(|k| {
+        (k == "spark.sql.session.timeZone").then_some("America/Los_Angeles")
+    });
+    assert_eq!(region.session_zone, None);
+    let bad =
+        ResolutionConf::from_conf(|k| (k == "spark.sql.session.timeZone").then_some("Mars/Base"));
+    assert_eq!(bad.session_zone, None);
     // Analysis has no configuration source besides `AnalysisContext::conf`
     // (the type holds none): the same context gives the same result.
     let c = ctx();
@@ -1939,6 +1956,135 @@ fn try_arithmetic_casts_its_arguments_in_try_mode() {
     assert!(try_add.output[0].nullable);
 }
 
+/// Typed datetime literals resolve in the analyzer with the session zone.
+#[test]
+fn typed_literals_resolve_with_the_session_zone() {
+    use crate::{ExprNode, Literal, LogicalPlan, Plan, PlanNode, ResolvedExpr, TypedLiteralKind};
+    let project = |kind: TypedLiteralKind, value: &str, conf: ResolutionConf| {
+        let expr = Expr::new(ExprNode::TypedLiteral {
+            kind,
+            value: value.to_owned(),
+        });
+        let plan = LogicalPlan::new(crate::PlanNode::Project {
+            input: std::sync::Arc::new(LogicalPlan::new(crate::PlanNode::OneRowRelation)),
+            exprs: vec![std::sync::Arc::new(expr)],
+        });
+        let plan = Plan::try_new(plan).unwrap();
+        let ctx = context(MemoryCatalog::new("spark_catalog"), conf);
+        block_on(DefaultAnalyzer.analyze(&plan, &ctx))
+    };
+    // The instant a one-column project holds, unwrapping its alias.
+    let micros_of = |plan: &LogicalPlan| {
+        let PlanNode::Project { exprs, .. } = &plan.node else {
+            panic!("not a project: {plan}");
+        };
+        let inner = match &exprs[0].node {
+            ExprNode::Resolved(ResolvedExpr::Alias { expr, .. }) => expr,
+            ExprNode::Literal(_) => &exprs[0],
+            other => panic!("not a literal: {other:?}"),
+        };
+        match &inner.node {
+            ExprNode::Literal(Literal::Timestamp(v)) => *v,
+            other => panic!("not a timestamp: {other:?}"),
+        }
+    };
+    let utc = ResolutionConf {
+        session_zone: Some(0),
+        ..ResolutionConf::default()
+    };
+    let plus = ResolutionConf {
+        session_zone: Some(19_800),
+        ..ResolutionConf::default()
+    };
+    let ntz_conf = ResolutionConf {
+        timestamp_ntz: true,
+        session_zone: Some(0),
+        ..ResolutionConf::default()
+    };
+    let region = ResolutionConf {
+        session_zone: None,
+        ..ResolutionConf::default()
+    };
+    // Plain `TIMESTAMP` is an instant by default, wall-clock under NTZ.
+    let a = project(TypedLiteralKind::Timestamp, "2024-01-01 10:00:00", utc).unwrap();
+    assert_eq!(a.output[0].data_type.simple_string(), "timestamp");
+    assert_eq!(a.output[0].name, "TIMESTAMP '2024-01-01 10:00:00'");
+    let a = project(TypedLiteralKind::Timestamp, "2024-01-01 10:00:00", ntz_conf).unwrap();
+    assert_eq!(a.output[0].data_type.simple_string(), "timestamp_ntz");
+    assert_eq!(a.output[0].name, "TIMESTAMP_NTZ '2024-01-01 10:00:00'");
+    // An explicit zone stays an instant under NTZ and ignores the session.
+    let a = project(
+        TypedLiteralKind::Timestamp,
+        "2024-01-01 10:00:00+05:30",
+        ntz_conf,
+    )
+    .unwrap();
+    assert_eq!(a.output[0].data_type.simple_string(), "timestamp");
+    // The session zone moves wall-clock instants (`+05:30` is 04:30 UTC):
+    // Spark 4.2 gives 1_704_103_200_000_000 µs in UTC and
+    // 1_704_083_400_000_000 µs in +05:30.
+    let utc_plan = project(TypedLiteralKind::Timestamp, "2024-01-01 10:00:00", utc).unwrap();
+    let plus_plan = project(TypedLiteralKind::Timestamp, "2024-01-01 10:00:00", plus).unwrap();
+    assert_eq!(micros_of(utc_plan.plan.root()), 1_704_103_200_000_000);
+    assert_eq!(micros_of(plus_plan.plan.root()), 1_704_083_400_000_000);
+    let a = project(
+        TypedLiteralKind::Timestamp,
+        "2024-01-01 10:00:00+00:00",
+        plus,
+    )
+    .unwrap();
+    assert_eq!(a.output[0].name, "TIMESTAMP '2024-01-01 15:30:00'");
+    // `DATE` resolves without a zone.
+    let a = project(TypedLiteralKind::Date, "2016-03-12", utc).unwrap();
+    assert_eq!(a.output[0].name, "DATE '2016-03-12'");
+    assert_eq!(a.output[0].data_type.simple_string(), "date");
+    // Malformed text is `INVALID_TYPED_LITERAL`.
+    for (kind, value) in [
+        (TypedLiteralKind::Timestamp, "2024-13-01 10:00:00"),
+        (TypedLiteralKind::TimestampNtz, "10:00"),
+        (TypedLiteralKind::Date, "2020-02-30"),
+        (TypedLiteralKind::Date, "not-a-date"),
+        (TypedLiteralKind::Date, "10:00"),
+    ] {
+        let e = project(kind, value, utc).unwrap_err();
+        assert_eq!(
+            e.error.error_class(),
+            ErrorClass::InvalidTypedLiteral,
+            "{value}"
+        );
+    }
+    // Clock-dependent spellings need the query clock.
+    for (kind, value) in [
+        (TypedLiteralKind::Timestamp, "now"),
+        (TypedLiteralKind::TimestampLtz, "10:00"),
+        (TypedLiteralKind::Timestamp, "10:00"),
+    ] {
+        let e = project(kind, value, utc).unwrap_err();
+        assert_eq!(
+            e.error.error_class(),
+            ErrorClass::KrishivUnsupportedFeature,
+            "{value}"
+        );
+    }
+    // A region session serves explicit zones but not wall-clock time.
+    project(
+        TypedLiteralKind::Timestamp,
+        "2024-01-01 10:00:00+05:30",
+        region,
+    )
+    .unwrap();
+    let e = project(TypedLiteralKind::Timestamp, "2024-01-01 10:00:00", region).unwrap_err();
+    assert_eq!(e.error.error_class(), ErrorClass::KrishivUnsupportedFeature);
+    // A region id in the value needs the time-zone database.
+    let e = project(
+        TypedLiteralKind::Timestamp,
+        "2024-01-01 10:00:00 America/Los_Angeles",
+        utc,
+    )
+    .unwrap_err();
+    assert_eq!(e.error.error_class(), ErrorClass::KrishivUnsupportedFeature);
+}
+
 /// A conditional with `FILTER` names the filter once: the shown call takes
 /// only the function's own arguments, not the filter child.
 #[test]
diff --git a/crates/krishiv-plan/src/tests/inventory.rs b/crates/krishiv-plan/src/tests/inventory.rs
index 8f6f1dc6..e88269d6 100644
--- a/crates/krishiv-plan/src/tests/inventory.rs
+++ b/crates/krishiv-plan/src/tests/inventory.rs
@@ -52,6 +52,7 @@ fn expr_kinds(expr: &Expr, out: &mut BTreeSet<&'static str>) {
     out.insert(match &expr.node {
         ExprNode::Column(_) => "ExprNode::Column",
         ExprNode::Literal(_) => "ExprNode::Literal",
+        ExprNode::TypedLiteral { .. } => "ExprNode::TypedLiteral",
         ExprNode::Star(_) => "ExprNode::Star",
         ExprNode::Function(_) => "ExprNode::Function",
         ExprNode::Cast { .. } => "ExprNode::Cast",
diff --git a/crates/krishiv-plan/src/tests/props.rs b/crates/krishiv-plan/src/tests/props.rs
index 9a90ce79..52ccaf8c 100644
--- a/crates/krishiv-plan/src/tests/props.rs
+++ b/crates/krishiv-plan/src/tests/props.rs
@@ -673,6 +673,7 @@ fn m_expr(e: &mut Arc<Expr>, w: &mut Walk) -> bool {
     match &mut e.node {
         ExprNode::Column(ColumnRef { name, .. }) => m_strings(name, w),
         ExprNode::Literal(v) => m_literal(v, w),
+        ExprNode::TypedLiteral { value, .. } => m_string(value, w),
         ExprNode::Star(Star { qualifier, .. }) => m_strings(qualifier, w),
         ExprNode::Function(FunctionCall {
             name,
diff --git a/crates/krishiv-plan/src/walk.rs b/crates/krishiv-plan/src/walk.rs
index ddd66b2f..a6bdaa88 100644
--- a/crates/krishiv-plan/src/walk.rs
+++ b/crates/krishiv-plan/src/walk.rs
@@ -162,6 +162,7 @@ pub(crate) fn all_resolved(root: Node<'_>) -> bool {
             Node::Expr(e) => match &e.node {
                 ExprNode::Column(_)
                 | ExprNode::Star(_)
+                | ExprNode::TypedLiteral { .. }
                 | ExprNode::Function(_)
                 | ExprNode::Alias { .. } => false,
                 ExprNode::Cast { mode, .. } => match mode {
@@ -336,6 +337,7 @@ impl Teardown {
         match node {
             ExprNode::Column(_)
             | ExprNode::Literal(_)
+            | ExprNode::TypedLiteral { .. }
             | ExprNode::Star(_)
             | ExprNode::Resolved(ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_)) => {}
             ExprNode::Function(FunctionCall { args, filter, .. })
diff --git a/crates/krishiv-session/tests/session.rs b/crates/krishiv-session/tests/session.rs
index eaa5d239..4dfe8d47 100644
--- a/crates/krishiv-session/tests/session.rs
+++ b/crates/krishiv-session/tests/session.rs
@@ -1159,6 +1159,60 @@ fn decimal_quotients_round_before_they_are_summed() {
     );
 }
 
+/// Typed datetime literals resolve in the analyzer with the session zone:
+/// the default session (no `spark.sql.session.timeZone`) reads plain
+/// `TIMESTAMP '...'` as UTC, and output names render in the session zone.
+#[test]
+fn typed_timestamp_literals_use_the_session_zone() {
+    use arrow_array::types::TimestampMicrosecondType;
+    // The default session works: `2024-01-01 10:00:00` is 10:00 UTC.
+    let s = Session::new().unwrap();
+    let df = block_on(s.sql("SELECT TIMESTAMP '2024-01-01 10:00:00'")).unwrap();
+    let schema = block_on(df.schema()).unwrap();
+    assert_eq!(schema.field(0).name(), "TIMESTAMP '2024-01-01 10:00:00'");
+    let batches = block_on(
+        block_on(s.sql("SELECT TIMESTAMP '2024-01-01 10:00:00'"))
+            .unwrap()
+            .collect(),
+    )
+    .unwrap();
+    assert_eq!(batches[0].num_rows(), 1);
+    assert_eq!(
+        batches[0]
+            .column(0)
+            .as_primitive::<TimestampMicrosecondType>()
+            .value(0),
+        1_704_103_200_000_000
+    );
+    // A non-UTC session zone moves instants without a zone, and names
+    // render in that zone, not in UTC.
+    let s = Session::builder()
+        .config("spark.sql.session.timeZone", "+05:30")
+        .build()
+        .unwrap();
+    let df = block_on(s.sql("SELECT TIMESTAMP '2024-01-01 10:00:00'")).unwrap();
+    let schema = block_on(df.schema()).unwrap();
+    assert_eq!(schema.field(0).name(), "TIMESTAMP '2024-01-01 10:00:00'");
+    let batches = block_on(
+        block_on(s.sql("SELECT TIMESTAMP '2024-01-01 10:00:00'"))
+            .unwrap()
+            .collect(),
+    )
+    .unwrap();
+    assert_eq!(
+        batches[0]
+            .column(0)
+            .as_primitive::<TimestampMicrosecondType>()
+            .value(0),
+        1_704_083_400_000_000
+    );
+    // An explicit zone ignores the session zone for the value, but the
+    // name still renders in it: 10:00 UTC is 15:30 in +05:30.
+    let df = block_on(s.sql("SELECT TIMESTAMP '2024-01-01 10:00:00+00:00'")).unwrap();
+    let schema = block_on(df.schema()).unwrap();
+    assert_eq!(schema.field(0).name(), "TIMESTAMP '2024-01-01 15:30:00'");
+}
+
 #[test]
 fn expression_strings_select_filter_and_resolve() {
     use krishiv_session::functions::expr;
diff --git a/crates/krishiv-sql/src/lower.rs b/crates/krishiv-sql/src/lower.rs
index 08bfe35a..e204a9d2 100644
--- a/crates/krishiv-sql/src/lower.rs
+++ b/crates/krishiv-sql/src/lower.rs
@@ -25,8 +25,8 @@ use krishiv_plan::{
     Builtin, CastMode, ColumnRef, Cte, Expr as IrExpr, ExprNode, FrameBound as IrFrameBound,
     FrameUnits as IrFrameUnits, FunctionCall, Grouping, JoinCondition, JoinKind as IrJoin,
     Literal as IrLiteral, LogicalPlan, Origin, Plan, PlanNode, ReadSource, SortOrder, SourceId,
-    Star, SubqueryKind, WindowExpr, WindowFrame as IrWindowFrame, WindowSpec as IrWindowSpec,
-    WindowSpecRef,
+    Star, SubqueryKind, TypedLiteralKind as IrTypedKind, WindowExpr, WindowFrame as IrWindowFrame,
+    WindowSpec as IrWindowSpec, WindowSpecRef,
 };
 use krishiv_types::DecimalType;
 
@@ -44,6 +44,11 @@ type R<T> = Result<T, ParseError>;
 
 /// Parses and lowers one query; spans index `source`.
 ///
+/// Typed datetime literals (`TIMESTAMP '...'`, `TIMESTAMP_LTZ '...'`,
+/// `TIMESTAMP_NTZ '...'`, `DATE '...'`) lower to an unresolved
+/// [`ExprNode::TypedLiteral`] (the type keyword and the raw string): the
+/// analyzer resolves them with the session's time zone and timestamp type.
+///
 /// # Errors
 /// A [`ParseError`]: the parser's, or a lowering error with its span.
 pub fn parse_and_lower(sql: &str, options: &ParserOptions, source: SourceId) -> R<Plan> {
@@ -790,7 +795,7 @@ impl Lowerer {
     fn expr_inner(&mut self, e: &Expr) -> R<IrExpr> {
         let sp = e.span;
         Ok(match &e.kind {
-            ExprKind::Literal(v) => self.ex(ExprNode::Literal(literal(v, sp)?), sp),
+            ExprKind::Literal(v) => self.ex(literal(v, sp)?, sp),
             ExprKind::Keyword(k) => {
                 self.ex(ExprNode::Literal(IrLiteral::String(k.value.clone())), sp)
             }
@@ -1190,21 +1195,34 @@ fn is_path(s: &str) -> bool {
     s.contains('/') || s.contains(':')
 }
 
-fn literal(v: &Literal, sp: Span) -> R<IrLiteral> {
+fn literal(v: &Literal, sp: Span) -> R<ExprNode> {
     Ok(match v {
-        Literal::Null => IrLiteral::Null(None),
-        Literal::Boolean(b) => IrLiteral::Boolean(*b),
-        Literal::String(s) => IrLiteral::String(s.clone()),
-        Literal::Number { text, kind } => number(text, *kind, sp)?,
+        Literal::Null => ExprNode::Literal(IrLiteral::Null(None)),
+        Literal::Boolean(b) => ExprNode::Literal(IrLiteral::Boolean(*b)),
+        Literal::String(s) => ExprNode::Literal(IrLiteral::String(s.clone())),
+        Literal::Number { text, kind } => ExprNode::Literal(number(text, *kind, sp)?),
         Literal::Typed { type_name, value } => {
             let kind = TypedKind::of(&type_name.value, type_name.quoted).map_err(|e| err(e, sp))?;
             match kind {
-                TypedKind::Date => IrLiteral::Date(
-                    literal::date(value).ok_or_else(|| err(kind.invalid(value), sp))?,
-                ),
-                TypedKind::Binary => IrLiteral::Binary(
+                TypedKind::Date => ExprNode::TypedLiteral {
+                    kind: IrTypedKind::Date,
+                    value: value.clone(),
+                },
+                TypedKind::Timestamp => ExprNode::TypedLiteral {
+                    kind: IrTypedKind::Timestamp,
+                    value: value.clone(),
+                },
+                TypedKind::TimestampNtz => ExprNode::TypedLiteral {
+                    kind: IrTypedKind::TimestampNtz,
+                    value: value.clone(),
+                },
+                TypedKind::TimestampLtz => ExprNode::TypedLiteral {
+                    kind: IrTypedKind::TimestampLtz,
+                    value: value.clone(),
+                },
+                TypedKind::Binary => ExprNode::Literal(IrLiteral::Binary(
                     literal::hex(value).ok_or_else(|| err(kind.invalid(value), sp))?,
-                ),
+                )),
                 _ => {
                     let t = type_name.value.to_ascii_uppercase();
                     return Err(unsupported(&format!("{t} literals"), sp));
diff --git a/crates/krishiv-sql/src/tests.rs b/crates/krishiv-sql/src/tests.rs
index 0e700729..c43bae39 100644
--- a/crates/krishiv-sql/src/tests.rs
+++ b/crates/krishiv-sql/src/tests.rs
@@ -955,6 +955,72 @@ fn multipart_identifiers_parse_like_spark() {
     assert_eq!(e.error.error_class(), ErrorClass::ParseEmptyStatement);
 }
 
+/// Typed datetime literals lower to an unresolved node (the type keyword
+/// and the raw string), with no time zone involved: the analyzer resolves
+/// them with the session zone.
+#[test]
+fn typed_datetime_literals_lower_unresolved() {
+    use crate::ast::{ExprKind, SetExprKind};
+    use krishiv_plan::SourceId;
+
+    // Each kind keeps its keyword and raw string, with the literal's span,
+    // and lowers without a time zone.
+    for (sql, keyword) in [
+        ("SELECT DATE '2016-03-12'", "DATE"),
+        ("SELECT TIMESTAMP '2024-01-01 10:00:00'", "TIMESTAMP"),
+        (
+            "SELECT TIMESTAMP_NTZ '2024-01-01 10:00:00'",
+            "TIMESTAMP_NTZ",
+        ),
+        (
+            "SELECT TIMESTAMP_LTZ '2024-01-01 10:00:00'",
+            "TIMESTAMP_LTZ",
+        ),
+    ] {
+        let q = crate::parse_query(sql, &ParserOptions::default()).unwrap();
+        let SetExprKind::Select(s) = q.body.kind else {
+            panic!("{sql} is not a select");
+        };
+        let ExprKind::Literal(crate::ast::Literal::Typed { type_name, value }) =
+            s.projection[0].expr.kind.clone()
+        else {
+            panic!("{sql} is not a typed literal");
+        };
+        assert_eq!(type_name.value.to_ascii_uppercase(), keyword, "{sql}");
+        assert!(!value.is_empty(), "{sql}");
+        assert_eq!(s.projection[0].expr.span.range(), 7..sql.len(), "{sql}");
+        // Lowering succeeds with the default options (no zone) and keeps
+        // the raw text: the plan holds a `TypedLiteral`, never micros.
+        let plan = crate::parse_and_lower(sql, &ParserOptions::default(), SourceId(0)).unwrap();
+        let text = plan.root().to_string();
+        assert!(text.contains(&format!("{keyword} '")), "{sql}: {text}");
+    }
+    // The wall-clock text is preserved exactly, including an explicit zone.
+    let q = parser::parse_query_unchecked(
+        "SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'",
+        ParserOptions::default(),
+    )
+    .unwrap();
+    let SetExprKind::Select(s) = q.body.kind else {
+        panic!("not a select");
+    };
+    let ExprKind::Literal(crate::ast::Literal::Typed { value, .. }) =
+        s.projection[0].expr.kind.clone()
+    else {
+        panic!("not a typed literal");
+    };
+    assert_eq!(value, "2024-01-01 10:00:00+05:30");
+    let plan = crate::parse_and_lower(
+        "SELECT TIMESTAMP '2024-01-01 10:00:00'",
+        &ParserOptions::default(),
+        SourceId(0),
+    )
+    .unwrap();
+    let text = plan.root().to_string();
+    assert!(text.contains("TIMESTAMP '2024-01-01 10:00:00'"), "{text}");
+    assert!(!text.contains("1704103200000000"), "{text}");
+}
+
 /// `parse_named_expression`: one named expression (`F.expr`,
 /// `selectExpr` once per argument string, `filter`/`where` strings).
 #[test]
diff --git a/crates/krishiv-sql/tests/analyzer.rs b/crates/krishiv-sql/tests/analyzer.rs
index 74b960ce..145cd400 100644
--- a/crates/krishiv-sql/tests/analyzer.rs
+++ b/crates/krishiv-sql/tests/analyzer.rs
@@ -20,7 +20,7 @@ use krishiv_plan::analyzer::{
     ResolutionConf, TableColumn,
 };
 use krishiv_plan::{
-    AttrId, Builtin, Expr, ExprNode, FunctionId, JoinCondition, JoinKind, LogicalPlan,
+    AttrId, Builtin, Expr, ExprNode, FunctionId, JoinCondition, JoinKind, Literal, LogicalPlan,
     NullOrdering, PlanNode, ResolvedExpr, SortDirection, SourceId,
 };
 use krishiv_sql::{ParserOptions, parse_and_lower, redact_sql};
@@ -761,6 +761,153 @@ fn window_goldens_resolve_to_a_fixed_point() {
     assert!(failures.is_empty(), "{}", failures.join("\n"));
 }
 
+/// Typed datetime literals resolve in the analyzer with the session zone
+/// and timestamp type: plain `TIMESTAMP` follows
+/// `spark.sql.timestampType` (and a zone in the value), and instants
+/// without a zone read `spark.sql.session.timeZone`. The golden files
+/// (`literals.sql`, `timestamp.sql`, `timestampNTZ/timestamp.sql`,
+/// `datetime-*.sql`) record these names, rows and `INVALID_TYPED_LITERAL`
+/// errors.
+#[test]
+fn typed_timestamp_literals_resolve_like_spark() {
+    let g = goldens();
+    let analyze_with = |sql: &str, timestamp_ntz: bool, zone: Option<i32>| {
+        let conf = ResolutionConf {
+            timestamp_ntz,
+            session_zone: zone,
+            ..ResolutionConf::default()
+        };
+        let plan = parse_and_lower(sql, &ParserOptions::default(), SourceId(0)).map_err(|e| {
+            AnalysisError {
+                error: e.error,
+                origin: krishiv_plan::Origin::UNKNOWN,
+            }
+        })?;
+        block_on(DefaultAnalyzer.analyze(&plan, &context(catalog(&g), conf)))
+    };
+    let utc = Some(0);
+    // Plain `TIMESTAMP` is an instant by default, wall-clock under `TIMESTAMP_NTZ`.
+    let a = analyze_with("SELECT TIMESTAMP '2024-01-01 10:00:00'", false, utc).unwrap();
+    assert_eq!(a.output[0].data_type.simple_string(), "timestamp");
+    assert_eq!(a.output[0].name, "TIMESTAMP '2024-01-01 10:00:00'");
+    let a = analyze_with("SELECT TIMESTAMP '2024-01-01 10:00:00'", true, utc).unwrap();
+    assert_eq!(a.output[0].data_type.simple_string(), "timestamp_ntz");
+    assert_eq!(a.output[0].name, "TIMESTAMP_NTZ '2024-01-01 10:00:00'");
+    // ... unless the value names a zone, which stays an instant.
+    let a = analyze_with("SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'", true, utc).unwrap();
+    assert_eq!(a.output[0].data_type.simple_string(), "timestamp");
+    // The session zone moves instants without a zone (`+05:30` is 04:30 UTC):
+    // Spark 4.2 gives 1_704_103_200_000_000 µs in UTC and
+    // 1_704_083_400_000_000 µs in +05:30.
+    let utc_plan = analyze_with("SELECT TIMESTAMP '2024-01-01 10:00:00'", false, utc).unwrap();
+    let plus_plan = analyze_with(
+        "SELECT TIMESTAMP '2024-01-01 10:00:00'",
+        false,
+        Some(19_800),
+    )
+    .unwrap();
+    let micros_of = |plan: &LogicalPlan| {
+        let PlanNode::Project { exprs, .. } = &plan.node else {
+            panic!("not a project: {plan}");
+        };
+        let inner = match &exprs[0].node {
+            ExprNode::Resolved(ResolvedExpr::Alias { expr, .. }) => expr,
+            ExprNode::Literal(_) => &exprs[0],
+            other => panic!("not a literal: {other:?}"),
+        };
+        match &inner.node {
+            ExprNode::Literal(Literal::Timestamp(v)) => *v,
+            other => panic!("not a timestamp: {other:?}"),
+        }
+    };
+    assert_eq!(micros_of(utc_plan.plan.root()), 1_704_103_200_000_000);
+    assert_eq!(micros_of(plus_plan.plan.root()), 1_704_083_400_000_000);
+    // `TIMESTAMP_LTZ` and `TIMESTAMP_NTZ` keep their types.
+    let a = analyze_with("SELECT TIMESTAMP_LTZ '2024-01-01 10:00:00'", true, utc).unwrap();
+    assert_eq!(a.output[0].data_type.simple_string(), "timestamp");
+    let a = analyze_with("SELECT TIMESTAMP_NTZ '2024-01-01 10:00:00'", false, utc).unwrap();
+    assert_eq!(a.output[0].data_type.simple_string(), "timestamp_ntz");
+    // The session zone is unset by default (UTC): plain `TIMESTAMP` works.
+    let a = analyze_with("SELECT TIMESTAMP '2024-01-01 10:00:00'", false, Some(0)).unwrap();
+    assert_eq!(a.output[0].data_type.simple_string(), "timestamp");
+    // An explicit zone renders in a non-UTC session zone, not in UTC:
+    // 10:00 UTC is 15:30 in +05:30.
+    let a = analyze_with(
+        "SELECT TIMESTAMP '2024-01-01 10:00:00+00:00'",
+        false,
+        Some(19_800),
+    )
+    .unwrap();
+    assert_eq!(a.output[0].name, "TIMESTAMP '2024-01-01 15:30:00'");
+    // Spark's golden statements (`literals.sql`, `timestamp.sql`).
+    for (sql, name, ty) in [
+        (
+            "select tImEstAmp '2016-03-11 20:54:00.000'",
+            "TIMESTAMP '2016-03-11 20:54:00'",
+            "timestamp",
+        ),
+        (
+            "select timestamp '2019-01-01\t'",
+            "TIMESTAMP '2019-01-01 00:00:00'",
+            "timestamp",
+        ),
+        ("select dAte '2016-03-12'", "DATE '2016-03-12'", "date"),
+    ] {
+        let a = analyze_with(sql, false, utc).unwrap();
+        assert_eq!(a.output[0].name, name, "{sql}");
+        assert_eq!(a.output[0].data_type.simple_string(), ty, "{sql}");
+    }
+    // Invalid text is `INVALID_TYPED_LITERAL` at the literal.
+    for sql in [
+        "SELECT TIMESTAMP '2024-13-01 10:00:00'",
+        "SELECT TIMESTAMP_NTZ '10:00'",
+        "SELECT DATE '2020-02-30'",
+        "SELECT DATE '10:00'",
+    ] {
+        let e = analyze_with(sql, false, utc).unwrap_err();
+        assert_eq!(
+            e.error.error_class(),
+            krishiv_common::error::ErrorClass::InvalidTypedLiteral,
+            "{sql}"
+        );
+    }
+    // Clock-dependent spellings need the query clock.
+    for sql in [
+        "SELECT TIMESTAMP 'now'",
+        "SELECT TIMESTAMP_LTZ '10:00'",
+        "SELECT TIMESTAMP '10:00'",
+    ] {
+        let e = analyze_with(sql, false, utc).unwrap_err();
+        assert_eq!(
+            e.error.error_class(),
+            krishiv_common::error::ErrorClass::KrishivUnsupportedFeature,
+            "{sql}"
+        );
+        assert!(e.error.to_string().contains("query clock"), "{sql}: {e}");
+    }
+    // A region session zone serves explicit offsets but not wall-clock time.
+    let e = analyze_with("SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'", false, None).unwrap();
+    assert_eq!(e.output[0].data_type.simple_string(), "timestamp");
+    let e = analyze_with("SELECT TIMESTAMP '2024-01-01 10:00:00'", false, None).unwrap_err();
+    assert_eq!(
+        e.error.error_class(),
+        krishiv_common::error::ErrorClass::KrishivUnsupportedFeature,
+        "region session without zone"
+    );
+    // A region id in the value needs the time-zone database.
+    let e = analyze_with(
+        "SELECT TIMESTAMP '2024-01-01 10:00:00 America/Los_Angeles'",
+        false,
+        utc,
+    )
+    .unwrap_err();
+    assert_eq!(
+        e.error.error_class(),
+        krishiv_common::error::ErrorClass::KrishivUnsupportedFeature,
+        "region value"
+    );
+}
+
 /// Foldable expressions the analyzer evaluates for typing: casts to string
 /// and date, datetime functions of literals and function-form `concat`.
 /// Spark folds them at analysis time, so a `LIMIT`, a legacy day count and
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 f2785c44..ba0cd529 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
@@ -77,7 +77,7 @@ SELECT ? FROM t
 SELECT INTERVAL 1 DAY FROM t
   => [KRISHIV_UNSUPPORTED_FEATURE] The feature INTERVAL literals is not supported by Krishiv yet. SQLSTATE: 0A000 @ 7..21
 SELECT TIMESTAMP '2020-01-01 00:00:00' FROM t
-  => [KRISHIV_UNSUPPORTED_FEATURE] The feature TIMESTAMP literals is not supported by Krishiv yet. SQLSTATE: 0A000 @ 7..38
+  => Project [TIMESTAMP '2020-01-01 00:00:00'] | +- Read t | 
 SELECT db.f(a) FROM t
   => [KRISHIV_UNSUPPORTED_FEATURE] The feature qualified function names is not supported by Krishiv yet. SQLSTATE: 0A000 @ 7..11
 SELECT f(x => 1) FROM t
diff --git a/crates/krishiv-sql/tests/snapshots/lower__literals_are_typed_as_spark_types_them.snap b/crates/krishiv-sql/tests/snapshots/lower__literals_are_typed_as_spark_types_them.snap
index 51d3f49e..09e15c83 100644
--- a/crates/krishiv-sql/tests/snapshots/lower__literals_are_typed_as_spark_types_them.snap
+++ b/crates/krishiv-sql/tests/snapshots/lower__literals_are_typed_as_spark_types_them.snap
@@ -5,7 +5,7 @@ expression: "report(&[\"SELECT 2147483647, 2147483648, 9223372036854775808, 1Y,
 SELECT 2147483647, 2147483648, 9223372036854775808, 1Y, 1S, 1L, -0.050, .5, 5., 1e3, 1.5D, 1.5F, 1.5BD FROM t
   => Project [2147483647, 2147483648L, 9223372036854775808, 1Y, 1S, 1L, -0.050, 0.5, 5, 1000.0D, 1.5D, 1.5F, 1.5] | +- Read t | 
 SELECT X'1F', X'abc', DATE '2020-2-3', DATE '+2020', DATE '2020-02-29T10:00', DATE '-0044-03-15' FROM t
-  => Project [X'1F', X'0ABC', DATE '2020-02-03', DATE '2020-01-01', DATE '2020-02-29', DATE '-0044-03-15'] | +- Read t | 
+  => Project [X'1F', X'0ABC', DATE '2020-2-3', DATE '+2020', DATE '2020-02-29T10:00', DATE '-0044-03-15'] | +- Read t | 
 SELECT 300Y FROM t
   => [INVALID_NUMERIC_LITERAL_RANGE] Numeric literal 300 is outside the valid range for tinyint with minimum value of -128 and maximum value of 127. Please adjust the value accordingly. SQLSTATE: 22003 @ 7..11
 SELECT 40000S FROM t
diff --git a/tests/fixtures/analysis/registry-matrix-manifest.json b/tests/fixtures/analysis/registry-matrix-manifest.json
index 77a2df37..82392c7f 100644
--- a/tests/fixtures/analysis/registry-matrix-manifest.json
+++ b/tests/fixtures/analysis/registry-matrix-manifest.json
@@ -33,14 +33,6 @@
       "id": "abs#5095fc57b734/ansi_on",
       "reason": "SELECT abs(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "abs#76cef57c8372/ansi_off",
-      "reason": "SELECT abs(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "abs#76cef57c8372/ansi_on",
-      "reason": "SELECT abs(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "abs#9fc7640777fa/ansi_off",
       "reason": "SELECT abs(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -49,14 +41,6 @@
       "id": "abs#9fc7640777fa/ansi_on",
       "reason": "SELECT abs(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "abs#e3f1114c9805/ansi_off",
-      "reason": "SELECT abs(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "abs#e3f1114c9805/ansi_on",
-      "reason": "SELECT abs(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "abs#e4f82fd88cf4/ansi_off",
       "reason": "SELECT abs(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -81,14 +65,6 @@
       "id": "acos#19d853eeed59/ansi_on",
       "reason": "SELECT acos(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "acos#3cb85c93499d/ansi_off",
-      "reason": "SELECT acos(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "acos#3cb85c93499d/ansi_on",
-      "reason": "SELECT acos(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "acos#646618e3c77a/ansi_off",
       "reason": "SELECT acos(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -121,14 +97,6 @@
       "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"
     },
-    {
-      "id": "acos#deb2e1190f67/ansi_off",
-      "reason": "SELECT acos(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "acos#deb2e1190f67/ansi_on",
-      "reason": "SELECT acos(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "acosh#3bee273b22bf/ansi_off",
       "reason": "SELECT acosh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -153,14 +121,6 @@
       "id": "acosh#7395fd9dea44/ansi_on",
       "reason": "SELECT acosh(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "acosh#77d59afefe3f/ansi_off",
-      "reason": "SELECT acosh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "acosh#77d59afefe3f/ansi_on",
-      "reason": "SELECT acosh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "acosh#82fdddb3781c/ansi_off",
       "reason": "SELECT acosh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -169,14 +129,6 @@
       "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"
     },
-    {
-      "id": "acosh#b127a5f6abd6/ansi_off",
-      "reason": "SELECT acosh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "acosh#b127a5f6abd6/ansi_on",
-      "reason": "SELECT acosh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "acosh#de074fcfa8d3/ansi_off",
       "reason": "SELECT acosh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -193,14 +145,6 @@
       "id": "asin#31dfa83e35e0/ansi_on",
       "reason": "SELECT asin(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "asin#3de0823aad73/ansi_off",
-      "reason": "SELECT asin(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "asin#3de0823aad73/ansi_on",
-      "reason": "SELECT asin(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "asin#46cf5550770f/ansi_off",
       "reason": "SELECT asin(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -209,14 +153,6 @@
       "id": "asin#46cf5550770f/ansi_on",
       "reason": "SELECT asin(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "asin#532d2fcaba75/ansi_off",
-      "reason": "SELECT asin(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "asin#532d2fcaba75/ansi_on",
-      "reason": "SELECT asin(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "asin#8ebc5342cf7e/ansi_off",
       "reason": "SELECT asin(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -249,14 +185,6 @@
       "id": "asinh#46c7e19729ea/ansi_on",
       "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#5c914fd899db/ansi_off",
-      "reason": "SELECT asinh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "asinh#5c914fd899db/ansi_on",
-      "reason": "SELECT asinh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -273,14 +201,6 @@
       "id": "asinh#68bed1327e2a/ansi_on",
       "reason": "SELECT asinh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "asinh#ceafc850a234/ansi_off",
-      "reason": "SELECT asinh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "asinh#ceafc850a234/ansi_on",
-      "reason": "SELECT asinh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "asinh#d6f6666c7a87/ansi_off",
       "reason": "SELECT asinh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -313,14 +233,6 @@
       "id": "atan#75cdf2d56233/ansi_on",
       "reason": "SELECT atan(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "atan#8bd484e1ae2b/ansi_off",
-      "reason": "SELECT atan(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan#8bd484e1ae2b/ansi_on",
-      "reason": "SELECT atan(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "atan#9bdd27436277/ansi_off",
       "reason": "SELECT atan(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -345,14 +257,6 @@
       "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#f6421872f094/ansi_off",
-      "reason": "SELECT atan(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan#f6421872f094/ansi_on",
-      "reason": "SELECT atan(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -361,14 +265,6 @@
       "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#0fc7352ddcb6/ansi_off",
-      "reason": "SELECT atan2(0, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan2#0fc7352ddcb6/ansi_on",
-      "reason": "SELECT atan2(0, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "atan2#2efc7af90017/ansi_off",
       "reason": "SELECT atan2(0, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -433,30 +329,6 @@
       "id": "atan2#ba98c7f801fa/ansi_on",
       "reason": "SELECT atan2(0, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "atan2#c3b5a265df26/ansi_off",
-      "reason": "SELECT atan2(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan2#c3b5a265df26/ansi_on",
-      "reason": "SELECT atan2(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan2#d292f0dd3593/ansi_off",
-      "reason": "SELECT atan2(TIMESTAMP'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan2#d292f0dd3593/ansi_on",
-      "reason": "SELECT atan2(TIMESTAMP'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan2#d8c97756040c/ansi_off",
-      "reason": "SELECT atan2(0, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atan2#d8c97756040c/ansi_on",
-      "reason": "SELECT atan2(0, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -489,22 +361,6 @@
       "id": "atanh#48c6a42b6065/ansi_on",
       "reason": "SELECT atanh(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "atanh#5c707565484f/ansi_off",
-      "reason": "SELECT atanh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atanh#5c707565484f/ansi_on",
-      "reason": "SELECT atanh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atanh#65c2d6c09bd1/ansi_off",
-      "reason": "SELECT atanh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "atanh#65c2d6c09bd1/ansi_on",
-      "reason": "SELECT atanh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -561,14 +417,6 @@
       "id": "avg#ee0e059b8d96/ansi_on",
       "reason": "SELECT avg(col) FROM VALUES (CAST(2147483647 AS INT)), (CAST(2147483647 AS INT)) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: VALUES"
     },
-    {
-      "id": "bround#144dcf9ea4a3/ansi_off",
-      "reason": "SELECT bround(TIMESTAMP'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bround#144dcf9ea4a3/ansi_on",
-      "reason": "SELECT bround(TIMESTAMP'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "bround#1596f2acba8c/ansi_off",
       "reason": "SELECT bround(INTERVAL '1-2' YEAR TO MONTH, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -609,14 +457,6 @@
       "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#76ffa145b788/ansi_off",
-      "reason": "SELECT bround(2.5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bround#76ffa145b788/ansi_on",
-      "reason": "SELECT bround(2.5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "bround#8139bd9fdb4c/ansi_off",
       "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"
@@ -641,14 +481,6 @@
       "id": "bround#972098065b06/ansi_on",
       "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#afa265c73de9/ansi_off",
-      "reason": "SELECT bround(2.5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bround#afa265c73de9/ansi_on",
-      "reason": "SELECT bround(2.5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -657,14 +489,6 @@
       "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#d9682cfc9130/ansi_off",
-      "reason": "SELECT bround(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "bround#d9682cfc9130/ansi_on",
-      "reason": "SELECT bround(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "bround#e536627ae66a/ansi_off",
       "reason": "SELECT bround(2.5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -681,14 +505,6 @@
       "id": "btrim#02142a9cc3f9/ansi_on",
       "reason": "SELECT btrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "btrim#02ce24eefd1c/ansi_off",
-      "reason": "SELECT btrim(TIMESTAMP'2024-02-29 12:34:56.123456', 'SL') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "btrim#02ce24eefd1c/ansi_on",
-      "reason": "SELECT btrim(TIMESTAMP'2024-02-29 12:34:56.123456', 'SL') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "btrim#08b197e99878/ansi_off",
       "reason": "SELECT btrim(map('a', 1), 'SL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -697,14 +513,6 @@
       "id": "btrim#08b197e99878/ansi_on",
       "reason": "SELECT btrim(map('a', 1), 'SL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "btrim#0c9049de4b8a/ansi_off",
-      "reason": "SELECT btrim(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'SL') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "btrim#0c9049de4b8a/ansi_on",
-      "reason": "SELECT btrim(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'SL') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "btrim#1043c6b8f7d4/ansi_off",
       "reason": "SELECT btrim(X'', encode('SL', 'utf-8')) | KRISHIV_UNSUPPORTED_FEATURE: function encode"
@@ -769,14 +577,6 @@
       "id": "btrim#63c2c80017bb/ansi_on",
       "reason": "SELECT btrim(encode('    SparkSQL   ', 'utf-8')) | KRISHIV_UNSUPPORTED_FEATURE: function encode"
     },
-    {
-      "id": "btrim#6ea7db1944ca/ansi_off",
-      "reason": "SELECT btrim('SSparkSQLS', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "btrim#6ea7db1944ca/ansi_on",
-      "reason": "SELECT btrim('SSparkSQLS', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -841,14 +641,6 @@
       "id": "btrim#a4157eab9f21/ansi_on",
       "reason": "SELECT btrim(encode('SSparkSQLS', 'utf-8'), X'00FF7F80') | KRISHIV_UNSUPPORTED_FEATURE: function encode"
     },
-    {
-      "id": "btrim#c22faaafe5b2/ansi_off",
-      "reason": "SELECT btrim(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "btrim#c22faaafe5b2/ansi_on",
-      "reason": "SELECT btrim(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "btrim#c4dad9cf2d5b/ansi_off",
       "reason": "SELECT btrim(encode('SSparkSQLS', 'utf-8'), CAST(NULL AS binary)) | KRISHIV_UNSUPPORTED_FEATURE: function encode"
@@ -857,14 +649,6 @@
       "id": "btrim#c4dad9cf2d5b/ansi_on",
       "reason": "SELECT btrim(encode('SSparkSQLS', 'utf-8'), CAST(NULL AS binary)) | KRISHIV_UNSUPPORTED_FEATURE: function encode"
     },
-    {
-      "id": "btrim#c7286e7572fd/ansi_off",
-      "reason": "SELECT btrim('SSparkSQLS', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "btrim#c7286e7572fd/ansi_on",
-      "reason": "SELECT btrim('SSparkSQLS', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "btrim#d8226b5a98fe/ansi_off",
       "reason": "SELECT btrim('SSparkSQLS', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -889,14 +673,6 @@
       "id": "btrim#ddadbcba5fdc/ansi_on",
       "reason": "SELECT btrim(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "btrim#f8dd983263a5/ansi_off",
-      "reason": "SELECT btrim(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "btrim#f8dd983263a5/ansi_on",
-      "reason": "SELECT btrim(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "btrim#fce00137b143/ansi_off",
       "reason": "SELECT btrim(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -905,14 +681,6 @@
       "id": "btrim#fce00137b143/ansi_on",
       "reason": "SELECT btrim(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "cbrt#05e0867015dc/ansi_off",
-      "reason": "SELECT cbrt(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cbrt#05e0867015dc/ansi_on",
-      "reason": "SELECT cbrt(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "cbrt#10a3c47fd955/ansi_off",
       "reason": "SELECT cbrt(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -945,14 +713,6 @@
       "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#d8a91ca638b7/ansi_off",
-      "reason": "SELECT cbrt(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cbrt#d8a91ca638b7/ansi_on",
-      "reason": "SELECT cbrt(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "cbrt#fdb007bf9143/ansi_off",
       "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"
@@ -977,14 +737,6 @@
       "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#339d0e33873c/ansi_off",
-      "reason": "SELECT ceil(3.1411, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "ceil#339d0e33873c/ansi_on",
-      "reason": "SELECT ceil(3.1411, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
     {
       "id": "ceil#3ed3ac5ba694/ansi_off",
       "reason": "SELECT ceil(named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -1009,22 +761,6 @@
       "id": "ceil#4dce47b6e5a6/ansi_on",
       "reason": "SELECT ceil(3.1411, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has NON_FOLDABLE_ARGUMENT"
     },
-    {
-      "id": "ceil#539fb3f0969d/ansi_off",
-      "reason": "SELECT ceil(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceil#539fb3f0969d/ansi_on",
-      "reason": "SELECT ceil(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceil#58c009a3e04f/ansi_off",
-      "reason": "SELECT ceil(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceil#58c009a3e04f/ansi_on",
-      "reason": "SELECT ceil(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -1033,14 +769,6 @@
       "id": "ceil#5b3a37a449f4/ansi_on",
       "reason": "SELECT ceil(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ceil#5ffc67e781e2/ansi_off",
-      "reason": "SELECT ceil(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceil#5ffc67e781e2/ansi_on",
-      "reason": "SELECT ceil(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -1057,22 +785,6 @@
       "id": "ceil#7b7739e2b4bb/ansi_on",
       "reason": "SELECT ceil(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ceil#a51f057f1eb0/ansi_off",
-      "reason": "SELECT ceil(3.1411, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "ceil#a51f057f1eb0/ansi_on",
-      "reason": "SELECT ceil(3.1411, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "ceil#b4b9d23ae763/ansi_off",
-      "reason": "SELECT ceil(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceil#b4b9d23ae763/ansi_on",
-      "reason": "SELECT ceil(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ceil#bb23a5bd68bf/ansi_off",
       "reason": "SELECT ceil(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -1177,14 +889,6 @@
       "id": "ceiling#523bf03f299a/ansi_on",
       "reason": "SELECT ceiling(3.1411, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has NON_FOLDABLE_ARGUMENT"
     },
-    {
-      "id": "ceiling#5f6d2eeee5e3/ansi_off",
-      "reason": "SELECT ceiling(3.1411, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "ceiling#5f6d2eeee5e3/ansi_on",
-      "reason": "SELECT ceiling(3.1411, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
     {
       "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"
@@ -1201,22 +905,6 @@
       "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"
     },
-    {
-      "id": "ceiling#7a9a52e88a04/ansi_off",
-      "reason": "SELECT ceiling(3.1411, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "ceiling#7a9a52e88a04/ansi_on",
-      "reason": "SELECT ceiling(3.1411, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "ceiling#8cca33b62df8/ansi_off",
-      "reason": "SELECT ceiling(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceiling#8cca33b62df8/ansi_on",
-      "reason": "SELECT ceiling(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ceiling#8dd6b92218cd/ansi_off",
       "reason": "SELECT ceiling(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -1225,14 +913,6 @@
       "id": "ceiling#8dd6b92218cd/ansi_on",
       "reason": "SELECT ceiling(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ceiling#97ff6dde37a1/ansi_off",
-      "reason": "SELECT ceiling(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceiling#97ff6dde37a1/ansi_on",
-      "reason": "SELECT ceiling(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ceiling#a881960ea852/ansi_off",
       "reason": "SELECT ceiling(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -1241,14 +921,6 @@
       "id": "ceiling#a881960ea852/ansi_on",
       "reason": "SELECT ceiling(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ceiling#bc67e21a2b3c/ansi_off",
-      "reason": "SELECT ceiling(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceiling#bc67e21a2b3c/ansi_on",
-      "reason": "SELECT ceiling(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -1257,14 +929,6 @@
       "id": "ceiling#c2037689a057/ansi_on",
       "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#c582b334cb53/ansi_off",
-      "reason": "SELECT ceiling(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ceiling#c582b334cb53/ansi_on",
-      "reason": "SELECT ceiling(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ceiling#edc642c068e1/ansi_off",
       "reason": "SELECT ceiling(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT"
@@ -1329,22 +993,6 @@
       "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#70c07a0a0e2b/ansi_off",
-      "reason": "SELECT char_length(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "char_length#70c07a0a0e2b/ansi_on",
-      "reason": "SELECT char_length(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "char_length#9e1077c24add/ansi_off",
-      "reason": "SELECT char_length(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "char_length#9e1077c24add/ansi_on",
-      "reason": "SELECT char_length(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "char_length#f6d2d8a18a6b/ansi_off",
       "reason": "SELECT char_length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -1393,30 +1041,6 @@
       "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#ea473863b467/ansi_off",
-      "reason": "SELECT character_length(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "character_length#ea473863b467/ansi_on",
-      "reason": "SELECT character_length(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "character_length#ed7232015f69/ansi_off",
-      "reason": "SELECT character_length(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "character_length#ed7232015f69/ansi_on",
-      "reason": "SELECT character_length(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "coalesce#12a33a1da3fc/ansi_off",
-      "reason": "SELECT coalesce(NULL, 1, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "coalesce#12a33a1da3fc/ansi_on",
-      "reason": "SELECT coalesce(NULL, 1, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "coalesce#14f80f6e45b3/ansi_off",
       "reason": "SELECT coalesce(NULL, map('a', 1), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function map"
@@ -1433,14 +1057,6 @@
       "id": "coalesce#180ee04bc98b/ansi_on",
       "reason": "SELECT coalesce(NULL, 1, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "coalesce#2b570c231101/ansi_off",
-      "reason": "SELECT coalesce(NULL, 1, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "coalesce#2b570c231101/ansi_on",
-      "reason": "SELECT coalesce(NULL, 1, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "coalesce#31842a9dbd4d/ansi_off",
       "reason": "SELECT coalesce(NULL, INTERVAL '1 02:03:04' DAY TO SECOND, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -1457,22 +1073,6 @@
       "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#39d875e2a98f/ansi_off",
-      "reason": "SELECT coalesce(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "coalesce#39d875e2a98f/ansi_on",
-      "reason": "SELECT coalesce(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "coalesce#5740df8b5857/ansi_off",
-      "reason": "SELECT coalesce(NULL, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "coalesce#5740df8b5857/ansi_on",
-      "reason": "SELECT coalesce(NULL, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "coalesce#58920259386f/ansi_off",
       "reason": "SELECT coalesce(map('a', 1), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -1497,14 +1097,6 @@
       "id": "coalesce#6790aeb96831/ansi_on",
       "reason": "SELECT coalesce(NULL, INTERVAL '1-2' YEAR TO MONTH, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "coalesce#679b6d4a1336/ansi_off",
-      "reason": "SELECT coalesce(NULL, TIMESTAMP'2024-02-29 12:34:56.123456', NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "coalesce#679b6d4a1336/ansi_on",
-      "reason": "SELECT coalesce(NULL, TIMESTAMP'2024-02-29 12:34:56.123456', NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -1569,14 +1161,6 @@
       "id": "coalesce#f707a07bd88b/ansi_on",
       "reason": "SELECT coalesce(NULL, named_struct('a', 1, 'b', 'x'), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct"
     },
-    {
-      "id": "coalesce#fcdba58448d9/ansi_off",
-      "reason": "SELECT coalesce(TIMESTAMP'2024-02-29 12:34:56.123456', 1, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "coalesce#fcdba58448d9/ansi_on",
-      "reason": "SELECT coalesce(TIMESTAMP'2024-02-29 12:34:56.123456', 1, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "contains#1399b878e567/ansi_off",
       "reason": "SELECT contains('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -1585,14 +1169,6 @@
       "id": "contains#1399b878e567/ansi_on",
       "reason": "SELECT contains('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "contains#442543abc39f/ansi_off",
-      "reason": "SELECT contains(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "contains#442543abc39f/ansi_on",
-      "reason": "SELECT contains(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "contains#4b1b8fa21e9e/ansi_off",
       "reason": "SELECT contains(INTERVAL '1 02:03:04' DAY TO SECOND, 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -1609,14 +1185,6 @@
       "id": "contains#5bee7c2dbe51/ansi_on",
       "reason": "SELECT contains('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "contains#657e069c9ef8/ansi_off",
-      "reason": "SELECT contains(TIMESTAMP'2024-02-29 12:34:56.123456', 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "contains#657e069c9ef8/ansi_on",
-      "reason": "SELECT contains(TIMESTAMP'2024-02-29 12:34:56.123456', 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "contains#6c826c84c7a4/ansi_off",
       "reason": "SELECT contains(INTERVAL '1-2' YEAR TO MONTH, 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -1641,14 +1209,6 @@
       "id": "contains#acc8127286a1/ansi_on",
       "reason": "SELECT contains('Spark SQL', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "contains#c0462fa7f0fa/ansi_off",
-      "reason": "SELECT contains('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "contains#c0462fa7f0fa/ansi_on",
-      "reason": "SELECT contains('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -1681,14 +1241,6 @@
       "id": "contains#ebccf89c15c8/ansi_on",
       "reason": "SELECT contains(map('a', 1), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "contains#fea6216e17ad/ansi_off",
-      "reason": "SELECT contains('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "contains#fea6216e17ad/ansi_on",
-      "reason": "SELECT contains('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "cos#0aa1d83e940a/ansi_off",
       "reason": "SELECT cos(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -1705,14 +1257,6 @@
       "id": "cos#26a1dc09a534/ansi_on",
       "reason": "SELECT cos(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "cos#36a157155bb0/ansi_off",
-      "reason": "SELECT cos(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cos#36a157155bb0/ansi_on",
-      "reason": "SELECT cos(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "cos#581fb00920dd/ansi_off",
       "reason": "SELECT cos(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -1729,14 +1273,6 @@
       "id": "cos#6e49e17c44c6/ansi_on",
       "reason": "SELECT cos(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "cos#94939b6df433/ansi_off",
-      "reason": "SELECT cos(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cos#94939b6df433/ansi_on",
-      "reason": "SELECT cos(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -1769,14 +1305,6 @@
       "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"
     },
-    {
-      "id": "cosh#45158fe3fa66/ansi_off",
-      "reason": "SELECT cosh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cosh#45158fe3fa66/ansi_on",
-      "reason": "SELECT cosh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "cosh#527850f62b1d/ansi_off",
       "reason": "SELECT cosh(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -1793,22 +1321,6 @@
       "id": "cosh#5551e3dc215f/ansi_on",
       "reason": "SELECT cosh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "cosh#78bc6b50e5e0/ansi_off",
-      "reason": "SELECT cosh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cosh#78bc6b50e5e0/ansi_on",
-      "reason": "SELECT cosh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cot#649a2d79a6cd/ansi_off",
-      "reason": "SELECT cot(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cot#649a2d79a6cd/ansi_on",
-      "reason": "SELECT cot(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -1849,14 +1361,6 @@
       "id": "cot#db40c1b79156/ansi_on",
       "reason": "SELECT cot(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "cot#eeeb7fbb3c5f/ansi_off",
-      "reason": "SELECT cot(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "cot#eeeb7fbb3c5f/ansi_on",
-      "reason": "SELECT cot(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "count#0bc95591b359/ansi_off",
       "reason": "SELECT count(*) FROM VALUES (NULL), (5), (5), (20) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: VALUES"
@@ -1921,14 +1425,6 @@
       "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"
     },
-    {
-      "id": "crc32#51343c27c7ca/ansi_off",
-      "reason": "SELECT crc32(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "crc32#51343c27c7ca/ansi_on",
-      "reason": "SELECT crc32(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "crc32#5e1ebcddcdfd/ansi_off",
       "reason": "SELECT crc32(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -1954,36 +1450,12 @@
       "reason": "SELECT crc32(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
-      "id": "crc32#a776649f4439/ansi_off",
-      "reason": "SELECT crc32(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "id": "csc#6872d52b92eb/ansi_off",
+      "reason": "SELECT csc(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
-      "id": "crc32#a776649f4439/ansi_on",
-      "reason": "SELECT crc32(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "csc#4a354783aeb9/ansi_off",
-      "reason": "SELECT csc(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "csc#4a354783aeb9/ansi_on",
-      "reason": "SELECT csc(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "csc#56ed1f0ce037/ansi_off",
-      "reason": "SELECT csc(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "csc#56ed1f0ce037/ansi_on",
-      "reason": "SELECT csc(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "csc#6872d52b92eb/ansi_off",
-      "reason": "SELECT csc(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "csc#6872d52b92eb/ansi_on",
-      "reason": "SELECT csc(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "id": "csc#6872d52b92eb/ansi_on",
+      "reason": "SELECT csc(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "csc#9a00661998eb/ansi_off",
@@ -2025,14 +1497,6 @@
       "id": "cume_dist#8e537826960c/ansi_on",
       "reason": "SELECT a, b, cume_dist() OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | parse: KRISHIV_UNSUPPORTED_FEATURE: VALUES"
     },
-    {
-      "id": "date_add#21463b8ad243/ansi_off",
-      "reason": "SELECT date_add('2016-07-30', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_add#21463b8ad243/ansi_on",
-      "reason": "SELECT date_add('2016-07-30', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "date_add#2870a363da2b/ansi_off",
       "reason": "SELECT date_add('2016-07-30', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2049,14 +1513,6 @@
       "id": "date_add#3bdf7ada3e68/ansi_on",
       "reason": "SELECT date_add(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_add#4d3e3878d8ea/ansi_off",
-      "reason": "SELECT date_add(TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_add#4d3e3878d8ea/ansi_on",
-      "reason": "SELECT date_add(TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "date_add#925969f2424a/ansi_off",
       "reason": "SELECT date_add(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2065,14 +1521,6 @@
       "id": "date_add#925969f2424a/ansi_on",
       "reason": "SELECT date_add(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_add#9b0545cebd16/ansi_off",
-      "reason": "SELECT date_add('2016-07-30', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_add#9b0545cebd16/ansi_on",
-      "reason": "SELECT date_add('2016-07-30', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -2097,14 +1545,6 @@
       "id": "date_add#ba2bfcb95b8b/ansi_on",
       "reason": "SELECT date_add('2016-07-30', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_add#bc416f0faf5b/ansi_off",
-      "reason": "SELECT date_add(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "date_add#bc416f0faf5b/ansi_on",
-      "reason": "SELECT date_add(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -2185,14 +1625,6 @@
       "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#6b706e1fdbb0/ansi_off",
-      "reason": "SELECT date_diff(TIMESTAMP'2024-02-29 12:34:56.123456', '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_diff#6b706e1fdbb0/ansi_on",
-      "reason": "SELECT date_diff(TIMESTAMP'2024-02-29 12:34:56.123456', '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "date_diff#7612d4b942ab/ansi_off",
       "reason": "SELECT date_diff('2009-07-31', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2201,14 +1633,6 @@
       "id": "date_diff#7612d4b942ab/ansi_on",
       "reason": "SELECT date_diff('2009-07-31', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_diff#9285e9b8c42d/ansi_off",
-      "reason": "SELECT date_diff('2009-07-31', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "date_diff#9285e9b8c42d/ansi_on",
-      "reason": "SELECT date_diff('2009-07-31', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "date_diff#9afec0436340/ansi_off",
       "reason": "SELECT date_diff('2009-07-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2217,14 +1641,6 @@
       "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"
     },
-    {
-      "id": "date_diff#9c89dd11f797/ansi_off",
-      "reason": "SELECT date_diff('2009-07-31', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_diff#9c89dd11f797/ansi_on",
-      "reason": "SELECT date_diff('2009-07-31', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "date_diff#d030945d4990/ansi_off",
       "reason": "SELECT date_diff(named_struct('a', 1, 'b', 'x'), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2241,14 +1657,6 @@
       "id": "date_diff#f819ff5d5ebb/ansi_on",
       "reason": "SELECT date_diff('2009-07-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_diff#fe5e5d492f52/ansi_off",
-      "reason": "SELECT date_diff(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "date_diff#fe5e5d492f52/ansi_on",
-      "reason": "SELECT date_diff(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "date_part#0385f876baf9/ansi_off",
       "reason": "SELECT date_part('MONTH', INTERVAL '2021-11' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -2257,53 +1665,21 @@
       "id": "date_part#0385f876baf9/ansi_on",
       "reason": "SELECT date_part('MONTH', INTERVAL '2021-11' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "date_part#077960a43a67/ansi_off",
-      "reason": "SELECT date_part('', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
-    {
-      "id": "date_part#077960a43a67/ansi_on",
-      "reason": "SELECT date_part('', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
     {
       "id": "date_part#0a4ee947f0cd/ansi_off",
-      "reason": "SELECT date_part(map('a', 1), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
+      "reason": "SELECT date_part(map('a', 1), TIMESTAMP '2019-08-12 01:00:00.123456') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has NON_FOLDABLE_ARGUMENT"
     },
     {
       "id": "date_part#0a4ee947f0cd/ansi_on",
-      "reason": "SELECT date_part(map('a', 1), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#0d009c5daf06/ansi_off",
-      "reason": "SELECT date_part(1.5D, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#0d009c5daf06/ansi_on",
-      "reason": "SELECT date_part(1.5D, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#10b9b861ea2a/ansi_off",
-      "reason": "SELECT date_part(DATE'2024-02-29', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#10b9b861ea2a/ansi_on",
-      "reason": "SELECT date_part(DATE'2024-02-29', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
+      "reason": "SELECT date_part(map('a', 1), TIMESTAMP '2019-08-12 01:00:00.123456') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has NON_FOLDABLE_ARGUMENT"
     },
     {
       "id": "date_part#186144d07620/ansi_off",
-      "reason": "SELECT date_part(named_struct('a', 1, 'b', 'x'), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
+      "reason": "SELECT date_part(named_struct('a', 1, 'b', 'x'), TIMESTAMP '2019-08-12 01:00:00.123456') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has NON_FOLDABLE_ARGUMENT"
     },
     {
       "id": "date_part#186144d07620/ansi_on",
-      "reason": "SELECT date_part(named_struct('a', 1, 'b', 'x'), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#1a849732e8d0/ansi_off",
-      "reason": "SELECT date_part(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#1a849732e8d0/ansi_on",
-      "reason": "SELECT date_part(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has NON_FOLDABLE_ARGUMENT"
+      "reason": "SELECT date_part(named_struct('a', 1, 'b', 'x'), TIMESTAMP '2019-08-12 01:00:00.123456') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has NON_FOLDABLE_ARGUMENT"
     },
     {
       "id": "date_part#2d8e71c6a7e2/ansi_off",
@@ -2313,54 +1689,6 @@
       "id": "date_part#2d8e71c6a7e2/ansi_on",
       "reason": "SELECT date_part('YEAR', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "date_part#38abdde635cb/ansi_off",
-      "reason": "SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#38abdde635cb/ansi_on",
-      "reason": "SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#3ac03e90ae09/ansi_off",
-      "reason": "SELECT date_part(CAST(1 AS TINYINT), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#3ac03e90ae09/ansi_on",
-      "reason": "SELECT date_part(CAST(1 AS TINYINT), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#3e2cc302be78/ansi_off",
-      "reason": "SELECT date_part(TIMESTAMP'2024-02-29 12:34:56.123456', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#3e2cc302be78/ansi_on",
-      "reason": "SELECT date_part(TIMESTAMP'2024-02-29 12:34:56.123456', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#43134890746f/ansi_off",
-      "reason": "SELECT date_part(true, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#43134890746f/ansi_on",
-      "reason": "SELECT date_part(true, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#47300ca097a2/ansi_off",
-      "reason": "SELECT date_part(CAST(NULL AS string), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#47300ca097a2/ansi_on",
-      "reason": "SELECT date_part(CAST(NULL AS string), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#4dd0b4f6398f/ansi_off",
-      "reason": "SELECT date_part(CAST(1.5 AS DECIMAL(10,2)), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#4dd0b4f6398f/ansi_on",
-      "reason": "SELECT date_part(CAST(1.5 AS DECIMAL(10,2)), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
     {
       "id": "date_part#4e04c424a4c6/ansi_off",
       "reason": "SELECT date_part('MINUTE', CAST(NULL AS interval day to second)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
@@ -2369,38 +1697,6 @@
       "id": "date_part#4e04c424a4c6/ansi_on",
       "reason": "SELECT date_part('MINUTE', CAST(NULL AS interval day to second)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
     },
-    {
-      "id": "date_part#4e3ff97f209c/ansi_off",
-      "reason": "SELECT date_part(X'01', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#4e3ff97f209c/ansi_on",
-      "reason": "SELECT date_part(X'01', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#4ffa791d826c/ansi_off",
-      "reason": "SELECT date_part(CAST(1 AS SMALLINT), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#4ffa791d826c/ansi_on",
-      "reason": "SELECT date_part(CAST(1 AS SMALLINT), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#5b39224e6c7d/ansi_off",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#5b39224e6c7d/ansi_on",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#5df04ae8bebf/ansi_off",
-      "reason": "SELECT date_part(CAST(1.5 AS DECIMAL(38,18)), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#5df04ae8bebf/ansi_on",
-      "reason": "SELECT date_part(CAST(1.5 AS DECIMAL(38,18)), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
     {
       "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"
@@ -2409,14 +1705,6 @@
       "id": "date_part#636c907f859b/ansi_on",
       "reason": "SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "date_part#7325cc178c1c/ansi_off",
-      "reason": "SELECT date_part(' \\t a\\u3000\\n ', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
-    {
-      "id": "date_part#7325cc178c1c/ansi_on",
-      "reason": "SELECT date_part(' \\t a\\u3000\\n ', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
     {
       "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"
@@ -2425,38 +1713,6 @@
       "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#7e8afc448e92/ansi_off",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP'2024-11-03 01:30:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#7e8afc448e92/ansi_on",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP'2024-11-03 01:30:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#824820c2257b/ansi_off",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP'2024-03-10 02:30:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#824820c2257b/ansi_on",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP'2024-03-10 02:30:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#8b29a01a8d19/ansi_off",
-      "reason": "SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#8b29a01a8d19/ansi_on",
-      "reason": "SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#a6fb1ec00422/ansi_off",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#a6fb1ec00422/ansi_on",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "date_part#a7d2bff3fe87/ansi_off",
       "reason": "SELECT date_part('days', interval 5 days 3 hours 7 minutes) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -2473,21 +1729,13 @@
       "id": "date_part#aa2f352b65fe/ansi_on",
       "reason": "SELECT date_part('YEAR', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "date_part#aab4f343bf44/ansi_off",
-      "reason": "SELECT date_part(NULL, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#aab4f343bf44/ansi_on",
-      "reason": "SELECT date_part(NULL, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "date_part#aee6337cfd66/ansi_off",
-      "reason": "SELECT date_part(array(1, 2), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
+      "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"
     },
     {
       "id": "date_part#aee6337cfd66/ansi_on",
-      "reason": "SELECT date_part(array(1, 2), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
+      "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"
     },
     {
       "id": "date_part#b27dc92b308a/ansi_off",
@@ -2507,27 +1755,11 @@
     },
     {
       "id": "date_part#ba58e9c10e06/ansi_off",
-      "reason": "SELECT date_part(CAST(X'C328FF' AS STRING), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
+      "reason": "SELECT date_part(CAST(X'C328FF' AS STRING), TIMESTAMP '2019-08-12 01:00:00.123456') | NON_FOLDABLE_ARGUMENT where Spark has INVALID_EXTRACT_FIELD"
     },
     {
       "id": "date_part#ba58e9c10e06/ansi_on",
-      "reason": "SELECT date_part(CAST(X'C328FF' AS STRING), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
-    {
-      "id": "date_part#bae08edd2ed0/ansi_off",
-      "reason": "SELECT date_part(CAST(1.5 AS FLOAT), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#bae08edd2ed0/ansi_on",
-      "reason": "SELECT date_part(CAST(1.5 AS FLOAT), TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#bc259b115a0c/ansi_off",
-      "reason": "SELECT date_part(1, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#bc259b115a0c/ansi_on",
-      "reason": "SELECT date_part(1, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
+      "reason": "SELECT date_part(CAST(X'C328FF' AS STRING), TIMESTAMP '2019-08-12 01:00:00.123456') | NON_FOLDABLE_ARGUMENT where Spark has INVALID_EXTRACT_FIELD"
     },
     {
       "id": "date_part#bd06f126ac33/ansi_off",
@@ -2537,30 +1769,6 @@
       "id": "date_part#bd06f126ac33/ansi_on",
       "reason": "SELECT date_part('YEAR', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_EXTRACT_FIELD"
     },
-    {
-      "id": "date_part#bd965a85a2d3/ansi_off",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP'1969-12-31 23:59:59.999999') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#bd965a85a2d3/ansi_on",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP'1969-12-31 23:59:59.999999') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_part#c16d4ef11ebe/ansi_off",
-      "reason": "SELECT date_part('1', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
-    {
-      "id": "date_part#c16d4ef11ebe/ansi_on",
-      "reason": "SELECT date_part('1', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
-    {
-      "id": "date_part#c5a68ec0fcd4/ansi_off",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "date_part#c5a68ec0fcd4/ansi_on",
-      "reason": "SELECT date_part('YEAR', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "date_part#c6e0e94f093c/ansi_off",
       "reason": "SELECT date_part('days', CAST(NULL AS interval day to minute)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
@@ -2569,22 +1777,6 @@
       "id": "date_part#c6e0e94f093c/ansi_on",
       "reason": "SELECT date_part('days', CAST(NULL AS interval day to minute)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
     },
-    {
-      "id": "date_part#cf344f91535b/ansi_off",
-      "reason": "SELECT date_part('Ä€日本語😀é', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
-    {
-      "id": "date_part#cf344f91535b/ansi_on",
-      "reason": "SELECT date_part('Ä€日本語😀é', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
-    {
-      "id": "date_part#d52de07521f6/ansi_off",
-      "reason": "SELECT date_part(1L, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "date_part#d52de07521f6/ansi_on",
-      "reason": "SELECT date_part(1L, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
     {
       "id": "date_part#d62df87d0a31/ansi_off",
       "reason": "SELECT date_part('YEAR', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2601,14 +1793,6 @@
       "id": "date_part#eb381059e762/ansi_on",
       "reason": "SELECT date_part('seconds', CAST(NULL AS interval hour to second)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
     },
-    {
-      "id": "date_part#ec592de2f04f/ansi_off",
-      "reason": "SELECT date_part('abc', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
-    {
-      "id": "date_part#ec592de2f04f/ansi_on",
-      "reason": "SELECT date_part('abc', TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has INVALID_EXTRACT_FIELD"
-    },
     {
       "id": "date_part#f146583c811a/ansi_off",
       "reason": "SELECT date_part(INTERVAL '1-2' YEAR TO MONTH, TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has NON_FOLDABLE_ARGUMENT"
@@ -2625,30 +1809,6 @@
       "id": "date_part#f774384fcc53/ansi_on",
       "reason": "SELECT date_part('MONTH', CAST(NULL AS interval year to month)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
     },
-    {
-      "id": "date_sub#02c58a29ac0c/ansi_off",
-      "reason": "SELECT date_sub('2016-07-30', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_sub#02c58a29ac0c/ansi_on",
-      "reason": "SELECT date_sub('2016-07-30', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_sub#1e36c047018d/ansi_off",
-      "reason": "SELECT date_sub('2016-07-30', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_sub#1e36c047018d/ansi_on",
-      "reason": "SELECT date_sub('2016-07-30', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "date_sub#207ee245b757/ansi_off",
-      "reason": "SELECT date_sub(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "date_sub#207ee245b757/ansi_on",
-      "reason": "SELECT date_sub(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "date_sub#3cf02a673ae2/ansi_off",
       "reason": "SELECT date_sub('2016-07-30', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2721,14 +1881,6 @@
       "id": "date_sub#f11afe47f79b/ansi_on",
       "reason": "SELECT date_sub(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_sub#f55a75dd9e6e/ansi_off",
-      "reason": "SELECT date_sub(TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "date_sub#f55a75dd9e6e/ansi_on",
-      "reason": "SELECT date_sub(TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "date_sub#f67743ec255a/ansi_off",
       "reason": "SELECT date_sub('2016-07-30', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2745,14 +1897,6 @@
       "id": "dateadd#09354e653fe5/ansi_on",
       "reason": "SELECT dateadd('2016-07-30', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "dateadd#174e7768dbf5/ansi_off",
-      "reason": "SELECT dateadd(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "dateadd#174e7768dbf5/ansi_on",
-      "reason": "SELECT dateadd(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -2769,14 +1913,6 @@
       "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"
     },
-    {
-      "id": "dateadd#23f7165309a0/ansi_off",
-      "reason": "SELECT dateadd(TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "dateadd#23f7165309a0/ansi_on",
-      "reason": "SELECT dateadd(TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -2801,14 +1937,6 @@
       "id": "dateadd#669b157a2a19/ansi_on",
       "reason": "SELECT dateadd(named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "dateadd#6e45147da727/ansi_off",
-      "reason": "SELECT dateadd('2016-07-30', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "dateadd#6e45147da727/ansi_on",
-      "reason": "SELECT dateadd('2016-07-30', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "dateadd#6f61cbe0aa81/ansi_off",
       "reason": "SELECT dateadd('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"
@@ -2833,14 +1961,6 @@
       "id": "dateadd#f04884c6faf2/ansi_on",
       "reason": "SELECT dateadd(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "dateadd#fcb7cd8c6a92/ansi_off",
-      "reason": "SELECT dateadd('2016-07-30', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "dateadd#fcb7cd8c6a92/ansi_on",
-      "reason": "SELECT dateadd('2016-07-30', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "dateadd#fd4dc537aa5b/ansi_off",
       "reason": "SELECT dateadd('2016-07-30', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2849,14 +1969,6 @@
       "id": "dateadd#fd4dc537aa5b/ansi_on",
       "reason": "SELECT dateadd('2016-07-30', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "datediff#167010ff3d56/ansi_off",
-      "reason": "SELECT datediff(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "datediff#167010ff3d56/ansi_on",
-      "reason": "SELECT datediff(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -2873,14 +1985,6 @@
       "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"
     },
-    {
-      "id": "datediff#22502e16ec63/ansi_off",
-      "reason": "SELECT datediff(TIMESTAMP'2024-02-29 12:34:56.123456', '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "datediff#22502e16ec63/ansi_on",
-      "reason": "SELECT datediff(TIMESTAMP'2024-02-29 12:34:56.123456', '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "datediff#2ba9347b2901/ansi_off",
       "reason": "SELECT datediff('2009-07-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2889,14 +1993,6 @@
       "id": "datediff#2ba9347b2901/ansi_on",
       "reason": "SELECT datediff('2009-07-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "datediff#2fb9f606a4a6/ansi_off",
-      "reason": "SELECT datediff('2009-07-31', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "datediff#2fb9f606a4a6/ansi_on",
-      "reason": "SELECT datediff('2009-07-31', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "datediff#37853cc4b2c4/ansi_off",
       "reason": "SELECT datediff(named_struct('a', 1, 'b', 'x'), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -2929,14 +2025,6 @@
       "id": "datediff#844299ffb54b/ansi_on",
       "reason": "SELECT datediff(INTERVAL '1-2' YEAR TO MONTH, '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "datediff#8a061a9d826c/ansi_off",
-      "reason": "SELECT datediff('2009-07-31', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "datediff#8a061a9d826c/ansi_on",
-      "reason": "SELECT datediff('2009-07-31', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -3001,22 +2089,6 @@
       "id": "day#d9d4eab30e81/ansi_on",
       "reason": "SELECT day(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "day#e2b8d6a38e1b/ansi_off",
-      "reason": "SELECT day(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "day#e2b8d6a38e1b/ansi_on",
-      "reason": "SELECT day(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "day#fd84c9a3f97a/ansi_off",
-      "reason": "SELECT day(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "day#fd84c9a3f97a/ansi_on",
-      "reason": "SELECT day(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "dayofmonth#0296012a73bf/ansi_off",
       "reason": "SELECT dayofmonth(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -3033,14 +2105,6 @@
       "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#5906432f3a43/ansi_off",
-      "reason": "SELECT dayofmonth(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "dayofmonth#5906432f3a43/ansi_on",
-      "reason": "SELECT dayofmonth(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "dayofmonth#63cbd5ac0445/ansi_off",
       "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"
@@ -3049,14 +2113,6 @@
       "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"
     },
-    {
-      "id": "dayofmonth#81b68b7625d8/ansi_off",
-      "reason": "SELECT dayofmonth(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "dayofmonth#81b68b7625d8/ansi_on",
-      "reason": "SELECT dayofmonth(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "dayofmonth#e5fa5fb796ec/ansi_off",
       "reason": "SELECT dayofmonth(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -3081,14 +2137,6 @@
       "id": "degrees#0f5e2f47c537/ansi_on",
       "reason": "SELECT degrees(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "degrees#8d4fbb751501/ansi_off",
-      "reason": "SELECT degrees(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "degrees#8d4fbb751501/ansi_on",
-      "reason": "SELECT degrees(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "degrees#9a381aac8d04/ansi_off",
       "reason": "SELECT degrees(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -3121,14 +2169,6 @@
       "id": "degrees#c29f7fcd2a89/ansi_on",
       "reason": "SELECT degrees(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "degrees#f25a20630422/ansi_off",
-      "reason": "SELECT degrees(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "degrees#f25a20630422/ansi_on",
-      "reason": "SELECT degrees(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "dense_rank#33978a0a2b37/ansi_off",
       "reason": "SELECT a, b, dense_rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | parse: KRISHIV_UNSUPPORTED_FEATURE: VALUES"
@@ -3137,22 +2177,6 @@
       "id": "dense_rank#33978a0a2b37/ansi_on",
       "reason": "SELECT a, b, dense_rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | parse: KRISHIV_UNSUPPORTED_FEATURE: VALUES"
     },
-    {
-      "id": "endswith#279b1454889c/ansi_off",
-      "reason": "SELECT endswith(TIMESTAMP'2024-02-29 12:34:56.123456', 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "endswith#279b1454889c/ansi_on",
-      "reason": "SELECT endswith(TIMESTAMP'2024-02-29 12:34:56.123456', 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "endswith#2af420681e82/ansi_off",
-      "reason": "SELECT endswith('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "endswith#2af420681e82/ansi_on",
-      "reason": "SELECT endswith('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "endswith#3b9e39c48ee6/ansi_off",
       "reason": "SELECT endswith('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -3201,22 +2225,6 @@
       "id": "endswith#7fc3b35cb0fa/ansi_on",
       "reason": "SELECT endswith(INTERVAL '1-2' YEAR TO MONTH, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "endswith#87eaae650be7/ansi_off",
-      "reason": "SELECT endswith('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "endswith#87eaae650be7/ansi_on",
-      "reason": "SELECT endswith('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "endswith#960bee5d992e/ansi_off",
-      "reason": "SELECT endswith(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "endswith#960bee5d992e/ansi_on",
-      "reason": "SELECT endswith(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -3249,14 +2257,6 @@
       "id": "endswith#dd88f7cef81d/ansi_on",
       "reason": "SELECT endswith(INTERVAL '1 02:03:04' DAY TO SECOND, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "exp#11b0e07df90b/ansi_off",
-      "reason": "SELECT exp(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "exp#11b0e07df90b/ansi_on",
-      "reason": "SELECT exp(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "exp#1f7bc89b5adf/ansi_off",
       "reason": "SELECT exp(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -3289,14 +2289,6 @@
       "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#f14394e1c62f/ansi_off",
-      "reason": "SELECT exp(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "exp#f14394e1c62f/ansi_on",
-      "reason": "SELECT exp(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "exp#f67051cd986a/ansi_off",
       "reason": "SELECT exp(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -3329,14 +2321,6 @@
       "id": "expm1#34c7be4db61b/ansi_on",
       "reason": "SELECT expm1(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "expm1#415ca60de788/ansi_off",
-      "reason": "SELECT expm1(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "expm1#415ca60de788/ansi_on",
-      "reason": "SELECT expm1(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "expm1#93eb72fe98cd/ansi_off",
       "reason": "SELECT expm1(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -3345,14 +2329,6 @@
       "id": "expm1#93eb72fe98cd/ansi_on",
       "reason": "SELECT expm1(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "expm1#c154817caa15/ansi_off",
-      "reason": "SELECT expm1(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "expm1#c154817caa15/ansi_on",
-      "reason": "SELECT expm1(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "expm1#f0e09d2782fb/ansi_off",
       "reason": "SELECT expm1(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -3401,30 +2377,6 @@
       "id": "extract#41d71df79123/ansi_on",
       "reason": "SELECT extract(HOUR FROM time '09:08:01.000001') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIME literals where Spark has UNSUPPORTED_TIME_TYPE"
     },
-    {
-      "id": "extract#6bb4e2757ff6/ansi_off",
-      "reason": "SELECT extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "extract#6bb4e2757ff6/ansi_on",
-      "reason": "SELECT extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "extract#75b1c470be5d/ansi_off",
-      "reason": "SELECT extract(SECONDS FROM timestamp'2019-10-01 00:00:01.000001') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "extract#75b1c470be5d/ansi_on",
-      "reason": "SELECT extract(SECONDS FROM timestamp'2019-10-01 00:00:01.000001') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "extract#88e85956d286/ansi_off",
-      "reason": "SELECT extract(week FROM timestamp'2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "extract#88e85956d286/ansi_on",
-      "reason": "SELECT extract(week FROM timestamp'2019-08-12 01:00:00.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "extract#a4c46c6c106f/ansi_off",
       "reason": "SELECT extract(MINUTE FROM time '09:08:01.000001') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIME literals where Spark has UNSUPPORTED_TIME_TYPE"
@@ -3881,14 +2833,6 @@
       "id": "floor#0c6d71158a9a/ansi_on",
       "reason": "SELECT floor(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "floor#153f548d5f6b/ansi_off",
-      "reason": "SELECT floor(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "floor#153f548d5f6b/ansi_on",
-      "reason": "SELECT floor(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "floor#2fd8abd3b4d5/ansi_off",
       "reason": "SELECT floor(3.1411, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has NON_FOLDABLE_ARGUMENT"
@@ -3897,14 +2841,6 @@
       "id": "floor#2fd8abd3b4d5/ansi_on",
       "reason": "SELECT floor(3.1411, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has NON_FOLDABLE_ARGUMENT"
     },
-    {
-      "id": "floor#31c917f6c3b4/ansi_off",
-      "reason": "SELECT floor(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "floor#31c917f6c3b4/ansi_on",
-      "reason": "SELECT floor(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "floor#341fd846f969/ansi_off",
       "reason": "SELECT floor(3.1411, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has NON_FOLDABLE_ARGUMENT"
@@ -3969,30 +2905,6 @@
       "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"
     },
-    {
-      "id": "floor#9e94f963a583/ansi_off",
-      "reason": "SELECT floor(3.1411, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "floor#9e94f963a583/ansi_on",
-      "reason": "SELECT floor(3.1411, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "floor#9fdc7b27638e/ansi_off",
-      "reason": "SELECT floor(3.1411, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "floor#9fdc7b27638e/ansi_on",
-      "reason": "SELECT floor(3.1411, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has NON_FOLDABLE_ARGUMENT"
-    },
-    {
-      "id": "floor#9fe353db4a42/ansi_off",
-      "reason": "SELECT floor(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "floor#9fe353db4a42/ansi_on",
-      "reason": "SELECT floor(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -4017,14 +2929,6 @@
       "id": "floor#e063de715f94/ansi_on",
       "reason": "SELECT floor(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "floor#e972bf290789/ansi_off",
-      "reason": "SELECT floor(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "floor#e972bf290789/ansi_on",
-      "reason": "SELECT floor(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -4073,30 +2977,6 @@
       "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"
     },
-    {
-      "id": "greatest#1b3e8e6fbcb1/ansi_off",
-      "reason": "SELECT greatest(10, 9, 2, 4, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#1b3e8e6fbcb1/ansi_on",
-      "reason": "SELECT greatest(10, 9, 2, 4, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#1e0423594ac0/ansi_off",
-      "reason": "SELECT greatest(10, 9, 2, 4, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#1e0423594ac0/ansi_on",
-      "reason": "SELECT greatest(10, 9, 2, 4, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#27033c736bd2/ansi_off",
-      "reason": "SELECT greatest(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#27033c736bd2/ansi_on",
-      "reason": "SELECT greatest(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "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"
@@ -4138,28 +3018,12 @@
       "reason": "SELECT greatest(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": "greatest#4d83881cdb71/ansi_off",
-      "reason": "SELECT greatest(10, named_struct('a', 1, 'b', 'x'), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#4d83881cdb71/ansi_on",
-      "reason": "SELECT greatest(10, named_struct('a', 1, 'b', 'x'), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#4f3e0b4b0bb5/ansi_off",
-      "reason": "SELECT greatest(TIMESTAMP'2024-02-29 12:34:56.123456', 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#4f3e0b4b0bb5/ansi_on",
-      "reason": "SELECT greatest(TIMESTAMP'2024-02-29 12:34:56.123456', 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#63f0c7e49a79/ansi_off",
-      "reason": "SELECT greatest(10, 9, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "id": "greatest#4d83881cdb71/ansi_off",
+      "reason": "SELECT greatest(10, named_struct('a', 1, 'b', 'x'), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
-      "id": "greatest#63f0c7e49a79/ansi_on",
-      "reason": "SELECT greatest(10, 9, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "id": "greatest#4d83881cdb71/ansi_on",
+      "reason": "SELECT greatest(10, named_struct('a', 1, 'b', 'x'), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
     {
       "id": "greatest#69f9244398a6/ansi_off",
@@ -4177,14 +3041,6 @@
       "id": "greatest#7421d8bc18eb/ansi_on",
       "reason": "SELECT greatest(10, 9, named_struct('a', 1, 'b', 'x'), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "greatest#7e8c153fc085/ansi_off",
-      "reason": "SELECT greatest(10, 9, 2, TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#7e8c153fc085/ansi_on",
-      "reason": "SELECT greatest(10, 9, 2, TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -4209,14 +3065,6 @@
       "id": "greatest#84abe3fe1684/ansi_on",
       "reason": "SELECT greatest(10, 9, 2, named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "greatest#8f0a9228c822/ansi_off",
-      "reason": "SELECT greatest(10, TIMESTAMP'2024-02-29 12:34:56.123456', 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#8f0a9228c822/ansi_on",
-      "reason": "SELECT greatest(10, TIMESTAMP'2024-02-29 12:34:56.123456', 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -4249,14 +3097,6 @@
       "id": "greatest#ac8fdf5710d4/ansi_on",
       "reason": "SELECT greatest(10, INTERVAL '1-2' YEAR TO MONTH, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "greatest#afe5868b3b6b/ansi_off",
-      "reason": "SELECT greatest(10, 9, 2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#afe5868b3b6b/ansi_on",
-      "reason": "SELECT greatest(10, 9, 2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "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"
@@ -4289,14 +3129,6 @@
       "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"
     },
-    {
-      "id": "greatest#c9456dd53a6a/ansi_off",
-      "reason": "SELECT greatest(10, 9, TIMESTAMP'2024-02-29 12:34:56.123456', 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#c9456dd53a6a/ansi_on",
-      "reason": "SELECT greatest(10, 9, TIMESTAMP'2024-02-29 12:34:56.123456', 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "greatest#d2ab6b7ae5ae/ansi_off",
       "reason": "SELECT greatest(10, 9, INTERVAL '1 02:03:04' DAY TO SECOND, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -4305,14 +3137,6 @@
       "id": "greatest#d2ab6b7ae5ae/ansi_on",
       "reason": "SELECT greatest(10, 9, INTERVAL '1 02:03:04' DAY TO SECOND, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "greatest#d2fc3be3d398/ansi_off",
-      "reason": "SELECT greatest(10, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "greatest#d2fc3be3d398/ansi_on",
-      "reason": "SELECT greatest(10, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "greatest#e07bc566123a/ansi_off",
       "reason": "SELECT greatest(10, map('a', 1), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -4347,11 +3171,11 @@
     },
     {
       "id": "hash#10a009d846e4/ansi_off",
-      "reason": "SELECT hash(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT hash(TIMESTAMP'2024-02-29 12:34:56.123456', 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) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT hash(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "hash#11dc78602219/ansi_off",
@@ -4451,11 +3275,11 @@
     },
     {
       "id": "hash#4662df6e4cfe/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
+      "reason": "SELECT hash('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | 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') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
+      "reason": "SELECT hash('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "hash#4a599039809c/ansi_off",
@@ -4539,11 +3363,11 @@
     },
     {
       "id": "hash#5a92f4b086c0/ansi_off",
-      "reason": "SELECT hash(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
+      "reason": "SELECT hash(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | 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) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
+      "reason": "SELECT hash(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "hash#68ccd0f7afcd/ansi_off",
@@ -4553,14 +3377,6 @@
       "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"
     },
-    {
-      "id": "hash#695054de9e5d/ansi_off",
-      "reason": "SELECT hash('Spark', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "hash#695054de9e5d/ansi_on",
-      "reason": "SELECT hash('Spark', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -4675,11 +3491,11 @@
     },
     {
       "id": "hash#a93fbeb6bcb3/ansi_off",
-      "reason": "SELECT hash('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT hash('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "hash#a93fbeb6bcb3/ansi_on",
-      "reason": "SELECT hash('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT hash('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "hash#ab6c7c5a6f40/ansi_off",
@@ -4753,14 +3569,6 @@
       "id": "hash#cf54e7b823e9/ansi_on",
       "reason": "SELECT hash(1.5D, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
-    {
-      "id": "hash#d843651ee2ae/ansi_off",
-      "reason": "SELECT hash('Spark', TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "hash#d843651ee2ae/ansi_on",
-      "reason": "SELECT hash('Spark', TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "hash#d8fe25feb621/ansi_off",
       "reason": "SELECT hash(CAST(X'C328FF' AS STRING), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
@@ -4857,22 +3665,6 @@
       "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#71d9251782a9/ansi_off",
-      "reason": "SELECT hypot(TIMESTAMP'2024-02-29 12:34:56.123456', 4) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "hypot#71d9251782a9/ansi_on",
-      "reason": "SELECT hypot(TIMESTAMP'2024-02-29 12:34:56.123456', 4) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "hypot#8222397aed19/ansi_off",
-      "reason": "SELECT hypot(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 4) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "hypot#8222397aed19/ansi_on",
-      "reason": "SELECT hypot(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 4) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "hypot#8ffd180f8baa/ansi_off",
       "reason": "SELECT hypot(3, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -4889,14 +3681,6 @@
       "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"
     },
-    {
-      "id": "hypot#c78980951129/ansi_off",
-      "reason": "SELECT hypot(3, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "hypot#c78980951129/ansi_on",
-      "reason": "SELECT hypot(3, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "hypot#e8004c8b463f/ansi_off",
       "reason": "SELECT hypot(named_struct('a', 1, 'b', 'x'), 4) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -4905,14 +3689,6 @@
       "id": "hypot#e8004c8b463f/ansi_on",
       "reason": "SELECT hypot(named_struct('a', 1, 'b', 'x'), 4) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "hypot#ea369e3f627f/ansi_off",
-      "reason": "SELECT hypot(3, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "hypot#ea369e3f627f/ansi_on",
-      "reason": "SELECT hypot(3, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -4921,14 +3697,6 @@
       "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": "if#0e45532ebf0b/ansi_off",
-      "reason": "SELECT if(TIMESTAMP'2024-02-29 12:34:56.123456', 'a', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "if#0e45532ebf0b/ansi_on",
-      "reason": "SELECT if(TIMESTAMP'2024-02-29 12:34:56.123456', 'a', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "if#164ab1aafa5c/ansi_off",
       "reason": "SELECT if(1 < 2, map('a', 1), 'b') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -4969,14 +3737,6 @@
       "id": "if#46cf48fd2a80/ansi_on",
       "reason": "SELECT if(1 < 2, 'a', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "if#58126bf42d3c/ansi_off",
-      "reason": "SELECT if(1 < 2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "if#58126bf42d3c/ansi_on",
-      "reason": "SELECT if(1 < 2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "if#5977ad6a486c/ansi_off",
       "reason": "SELECT if(1 < 2, 'a', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -4985,14 +3745,6 @@
       "id": "if#5977ad6a486c/ansi_on",
       "reason": "SELECT if(1 < 2, 'a', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "if#5d173e3dffa9/ansi_off",
-      "reason": "SELECT if(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'a', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "if#5d173e3dffa9/ansi_on",
-      "reason": "SELECT if(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'a', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -5041,14 +3793,6 @@
       "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"
     },
-    {
-      "id": "if#d39a7d50f040/ansi_off",
-      "reason": "SELECT if(1 < 2, TIMESTAMP'2024-02-29 12:34:56.123456', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "if#d39a7d50f040/ansi_on",
-      "reason": "SELECT if(1 < 2, TIMESTAMP'2024-02-29 12:34:56.123456', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "if#d83245d4f93d/ansi_off",
       "reason": "SELECT if(1 < 2, named_struct('a', 1, 'b', 'x'), 'b') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -5057,14 +3801,6 @@
       "id": "if#d83245d4f93d/ansi_on",
       "reason": "SELECT if(1 < 2, named_struct('a', 1, 'b', 'x'), 'b') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "if#d8accbc5a139/ansi_off",
-      "reason": "SELECT if(1 < 2, 'a', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "if#d8accbc5a139/ansi_on",
-      "reason": "SELECT if(1 < 2, 'a', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -5073,14 +3809,6 @@
       "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#e22dd6dba6a9/ansi_off",
-      "reason": "SELECT if(1 < 2, 'a', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "if#e22dd6dba6a9/ansi_on",
-      "reason": "SELECT if(1 < 2, 'a', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "if#ec0d1d6bf87a/ansi_off",
       "reason": "SELECT if(map('a', 1), 'a', 'b') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -5107,11 +3835,11 @@
     },
     {
       "id": "ifnull#1bf265d2ee73/ansi_off",
-      "reason": "SELECT ifnull(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "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_on",
-      "reason": "SELECT ifnull(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "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_off",
@@ -5267,11 +3995,11 @@
     },
     {
       "id": "ifnull#bfe8bb89a454/ansi_off",
-      "reason": "SELECT ifnull(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "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_on",
-      "reason": "SELECT ifnull(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "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_off",
@@ -5313,22 +4041,6 @@
       "id": "ifnull#e500a975bbe1/ansi_on",
       "reason": "SELECT ifnull(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "ifnull#e7b4269aec69/ansi_off",
-      "reason": "SELECT ifnull(NULL, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "ifnull#e7b4269aec69/ansi_on",
-      "reason": "SELECT ifnull(NULL, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "ifnull#f2aefdbedb8f/ansi_off",
-      "reason": "SELECT ifnull(NULL, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "ifnull#f2aefdbedb8f/ansi_on",
-      "reason": "SELECT ifnull(NULL, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -5769,14 +4481,6 @@
       "id": "last_value#fcc3a7dc0a8f/ansi_on",
       "reason": "SELECT last_value(col, CAST(1.5 AS DECIMAL(10,2))) FROM VALUES (10), (5), (NULL) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: VALUES where Spark has _LEGACY_ERROR_TEMP_1210"
     },
-    {
-      "id": "lcase#27bcd9b6a852/ansi_off",
-      "reason": "SELECT lcase(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "lcase#27bcd9b6a852/ansi_on",
-      "reason": "SELECT lcase(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "lcase#5f8ebfb97b33/ansi_off",
       "reason": "SELECT lcase(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -5793,14 +4497,6 @@
       "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#7a9f31bb10e1/ansi_off",
-      "reason": "SELECT lcase(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "lcase#7a9f31bb10e1/ansi_on",
-      "reason": "SELECT lcase(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "lcase#a43c0260bd5e/ansi_off",
       "reason": "SELECT lcase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -5833,14 +4529,6 @@
       "id": "least#0cf7212d2d65/ansi_on",
       "reason": "SELECT least(10, named_struct('a', 1, 'b', 'x'), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "least#18c447fd05bb/ansi_off",
-      "reason": "SELECT least(10, 9, 2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#18c447fd05bb/ansi_on",
-      "reason": "SELECT least(10, 9, 2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "least#266447befe5d/ansi_off",
       "reason": "SELECT least(10, 9, 2, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -5865,14 +4553,6 @@
       "id": "least#3109c3554932/ansi_on",
       "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#4ad91be203df/ansi_off",
-      "reason": "SELECT least(10, 9, 2, 4, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#4ad91be203df/ansi_on",
-      "reason": "SELECT least(10, 9, 2, 4, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "least#4b20b2ccd6ae/ansi_off",
       "reason": "SELECT least(10, 9, named_struct('a', 1, 'b', 'x'), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -5889,14 +4569,6 @@
       "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#4dae43399af6/ansi_off",
-      "reason": "SELECT least(10, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#4dae43399af6/ansi_on",
-      "reason": "SELECT least(10, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "least#4ded5ea86b66/ansi_off",
       "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"
@@ -5977,14 +4649,6 @@
       "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"
     },
-    {
-      "id": "least#83a0f1297e18/ansi_off",
-      "reason": "SELECT least(TIMESTAMP'2024-02-29 12:34:56.123456', 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#83a0f1297e18/ansi_on",
-      "reason": "SELECT least(TIMESTAMP'2024-02-29 12:34:56.123456', 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "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"
@@ -5993,30 +4657,6 @@
       "id": "least#844d108891b5/ansi_on",
       "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#881e52330ff4/ansi_off",
-      "reason": "SELECT least(10, 9, 2, 4, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#881e52330ff4/ansi_on",
-      "reason": "SELECT least(10, 9, 2, 4, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#9b0ee742159a/ansi_off",
-      "reason": "SELECT least(10, 9, TIMESTAMP'2024-02-29 12:34:56.123456', 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#9b0ee742159a/ansi_on",
-      "reason": "SELECT least(10, 9, TIMESTAMP'2024-02-29 12:34:56.123456', 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#a9984d415b96/ansi_off",
-      "reason": "SELECT least(10, TIMESTAMP'2024-02-29 12:34:56.123456', 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#a9984d415b96/ansi_on",
-      "reason": "SELECT least(10, TIMESTAMP'2024-02-29 12:34:56.123456', 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -6025,14 +4665,6 @@
       "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#bb17e8a04c46/ansi_off",
-      "reason": "SELECT least(10, 9, 2, TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#bb17e8a04c46/ansi_on",
-      "reason": "SELECT least(10, 9, 2, TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "least#c0cc79f3906c/ansi_off",
       "reason": "SELECT least(named_struct('a', 1, 'b', 'x'), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -6057,14 +4689,6 @@
       "id": "least#d3ab4c4be0fe/ansi_on",
       "reason": "SELECT least(10, 9, map('a', 1), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "least#d7789d10f350/ansi_off",
-      "reason": "SELECT least(10, 9, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#d7789d10f350/ansi_on",
-      "reason": "SELECT least(10, 9, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "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"
@@ -6089,14 +4713,6 @@
       "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"
     },
-    {
-      "id": "least#fde843d93d06/ansi_off",
-      "reason": "SELECT least(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "least#fde843d93d06/ansi_on",
-      "reason": "SELECT least(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "least#ffd4f0e1c278/ansi_off",
       "reason": "SELECT least(10, 9, 2, 4, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -6105,14 +4721,6 @@
       "id": "least#ffd4f0e1c278/ansi_on",
       "reason": "SELECT least(10, 9, 2, 4, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "length#023a2f9f70f9/ansi_off",
-      "reason": "SELECT length(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "length#023a2f9f70f9/ansi_on",
-      "reason": "SELECT length(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "length#3850ba7284e8/ansi_off",
       "reason": "SELECT length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6153,22 +4761,6 @@
       "id": "length#c9aa4be9c045/ansi_on",
       "reason": "SELECT length(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "length#e821124fb184/ansi_off",
-      "reason": "SELECT length(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "length#e821124fb184/ansi_on",
-      "reason": "SELECT length(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "ln#0d0452688c77/ansi_off",
-      "reason": "SELECT ln(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ln#0d0452688c77/ansi_on",
-      "reason": "SELECT ln(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "ln#20f59312532d/ansi_off",
       "reason": "SELECT ln(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6177,14 +4769,6 @@
       "id": "ln#20f59312532d/ansi_on",
       "reason": "SELECT ln(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ln#365c01e2b99f/ansi_off",
-      "reason": "SELECT ln(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "ln#365c01e2b99f/ansi_on",
-      "reason": "SELECT ln(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -6217,14 +4801,6 @@
       "id": "ln#e85171130f3f/ansi_on",
       "reason": "SELECT ln(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "log#16250f2e2f9f/ansi_off",
-      "reason": "SELECT log(10, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log#16250f2e2f9f/ansi_on",
-      "reason": "SELECT log(10, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -6233,22 +4809,6 @@
       "id": "log#2849851ffff9/ansi_on",
       "reason": "SELECT log(10, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "log#2d568a534c81/ansi_off",
-      "reason": "SELECT log(10, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log#2d568a534c81/ansi_on",
-      "reason": "SELECT log(10, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log#2f5c8d25c102/ansi_off",
-      "reason": "SELECT log(TIMESTAMP'2024-02-29 12:34:56.123456', 100) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log#2f5c8d25c102/ansi_on",
-      "reason": "SELECT log(TIMESTAMP'2024-02-29 12:34:56.123456', 100) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -6297,14 +4857,6 @@
       "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#abbd8b03a42d/ansi_off",
-      "reason": "SELECT log(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 100) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log#abbd8b03a42d/ansi_on",
-      "reason": "SELECT log(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 100) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "log#b29ab2f7e498/ansi_off",
       "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"
@@ -6353,14 +4905,6 @@
       "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"
     },
-    {
-      "id": "log10#47f3b92efc1f/ansi_off",
-      "reason": "SELECT log10(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log10#47f3b92efc1f/ansi_on",
-      "reason": "SELECT log10(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "log10#a5850baae0e0/ansi_off",
       "reason": "SELECT log10(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6377,14 +4921,6 @@
       "id": "log10#da87dd7585f8/ansi_on",
       "reason": "SELECT log10(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "log10#f472e15901de/ansi_off",
-      "reason": "SELECT log10(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log10#f472e15901de/ansi_on",
-      "reason": "SELECT log10(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "log1p#10a3a0932d37/ansi_off",
       "reason": "SELECT log1p(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6393,14 +4929,6 @@
       "id": "log1p#10a3a0932d37/ansi_on",
       "reason": "SELECT log1p(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "log1p#2bc038779dd3/ansi_off",
-      "reason": "SELECT log1p(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log1p#2bc038779dd3/ansi_on",
-      "reason": "SELECT log1p(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "log1p#406cb2466c70/ansi_off",
       "reason": "SELECT log1p(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6417,14 +4945,6 @@
       "id": "log1p#862526b1964b/ansi_on",
       "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#bcb2a42989dc/ansi_off",
-      "reason": "SELECT log1p(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log1p#bcb2a42989dc/ansi_on",
-      "reason": "SELECT log1p(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -6457,14 +4977,6 @@
       "id": "log2#2a2c31c8341e/ansi_on",
       "reason": "SELECT log2(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "log2#4aa4a5f1a16c/ansi_off",
-      "reason": "SELECT log2(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log2#4aa4a5f1a16c/ansi_on",
-      "reason": "SELECT log2(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "log2#5b428c8fab2e/ansi_off",
       "reason": "SELECT log2(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6489,14 +5001,6 @@
       "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#deb940f6e725/ansi_off",
-      "reason": "SELECT log2(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "log2#deb940f6e725/ansi_on",
-      "reason": "SELECT log2(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "lower#2130df7157cc/ansi_off",
       "reason": "SELECT lower(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -6505,14 +5009,6 @@
       "id": "lower#2130df7157cc/ansi_on",
       "reason": "SELECT lower(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "lower#23657963237a/ansi_off",
-      "reason": "SELECT lower(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "lower#23657963237a/ansi_on",
-      "reason": "SELECT lower(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "lower#3bb228f7d65c/ansi_off",
       "reason": "SELECT lower(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6529,14 +5025,6 @@
       "id": "lower#3e7f165b4997/ansi_on",
       "reason": "SELECT lower(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "lower#4f02e5555cb8/ansi_off",
-      "reason": "SELECT lower(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "lower#4f02e5555cb8/ansi_on",
-      "reason": "SELECT lower(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "lower#4feea7924ff5/ansi_off",
       "reason": "SELECT lower(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6561,14 +5049,6 @@
       "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#186e517d689c/ansi_off",
-      "reason": "SELECT lpad(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "lpad#186e517d689c/ansi_on",
-      "reason": "SELECT lpad(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -6617,14 +5097,6 @@
       "id": "lpad#39b23190194f/ansi_on",
       "reason": "SELECT lpad('hi', 5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "lpad#3d828241dad3/ansi_off",
-      "reason": "SELECT lpad('hi', TIMESTAMP'2024-02-29 12:34:56.123456', '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#3d828241dad3/ansi_on",
-      "reason": "SELECT lpad('hi', TIMESTAMP'2024-02-29 12:34:56.123456', '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -6665,14 +5137,6 @@
       "id": "lpad#4e9387380116/ansi_on",
       "reason": "SELECT lpad('hi', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "lpad#4ec9298be524/ansi_off",
-      "reason": "SELECT lpad('hi', 5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "lpad#4ec9298be524/ansi_on",
-      "reason": "SELECT lpad('hi', 5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "lpad#5b222c93b4c7/ansi_off",
       "reason": "SELECT lpad(named_struct('a', 1, 'b', 'x'), 5) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6697,14 +5161,6 @@
       "id": "lpad#612d6fc66471/ansi_on",
       "reason": "SELECT hex(lpad(X'00FF7F80', 5, unhex('1122'))) | KRISHIV_UNSUPPORTED_FEATURE: function hex"
     },
-    {
-      "id": "lpad#620cbebc23bb/ansi_off",
-      "reason": "SELECT lpad(TIMESTAMP'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "lpad#620cbebc23bb/ansi_on",
-      "reason": "SELECT lpad(TIMESTAMP'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -6761,14 +5217,6 @@
       "id": "lpad#8c909c22c278/ansi_on",
       "reason": "SELECT hex(lpad(X'00FF7F80', 5)) | KRISHIV_UNSUPPORTED_FEATURE: function hex"
     },
-    {
-      "id": "lpad#8f00a68539ba/ansi_off",
-      "reason": "SELECT lpad('hi', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#8f00a68539ba/ansi_on",
-      "reason": "SELECT lpad('hi', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "lpad#9a853a142660/ansi_off",
       "reason": "SELECT lpad('hi', INTERVAL '1-2' YEAR TO MONTH, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6809,14 +5257,6 @@
       "id": "lpad#b4b48276eb39/ansi_on",
       "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#bd9b293d1cbc/ansi_off",
-      "reason": "SELECT lpad('hi', 5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "lpad#bd9b293d1cbc/ansi_on",
-      "reason": "SELECT lpad('hi', 5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "lpad#bf46321927c0/ansi_off",
       "reason": "SELECT lpad('hi', 5, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6841,14 +5281,6 @@
       "id": "lpad#c58b05bb8b60/ansi_on",
       "reason": "SELECT hex(lpad(unhex('aabb'), 5, CAST(NULL AS binary))) | KRISHIV_UNSUPPORTED_FEATURE: function hex"
     },
-    {
-      "id": "lpad#da64d16a99bd/ansi_off",
-      "reason": "SELECT lpad(TIMESTAMP'2024-02-29 12:34:56.123456', 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "lpad#da64d16a99bd/ansi_on",
-      "reason": "SELECT lpad(TIMESTAMP'2024-02-29 12:34:56.123456', 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "lpad#dbfd66f4ecec/ansi_off",
       "reason": "SELECT lpad(INTERVAL '1-2' YEAR TO MONTH, 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -6865,14 +5297,6 @@
       "id": "lpad#de40b94f338b/ansi_on",
       "reason": "SELECT hex(lpad(X'', 5)) | KRISHIV_UNSUPPORTED_FEATURE: function hex"
     },
-    {
-      "id": "lpad#e94c54e05b7a/ansi_off",
-      "reason": "SELECT lpad('hi', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#e94c54e05b7a/ansi_on",
-      "reason": "SELECT lpad('hi', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "lpad#edbd77fd8cb2/ansi_off",
       "reason": "SELECT lpad('hi', named_struct('a', 1, 'b', 'x'), '??') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -6897,22 +5321,6 @@
       "id": "lpad#f5930f28714a/ansi_on",
       "reason": "SELECT lpad(INTERVAL '1 02:03:04' DAY TO SECOND, 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "lpad#f92125bbe3de/ansi_off",
-      "reason": "SELECT lpad('hi', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#f92125bbe3de/ansi_on",
-      "reason": "SELECT lpad('hi', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "lpad#f9b0c164c420/ansi_off",
-      "reason": "SELECT lpad(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "lpad#f9b0c164c420/ansi_on",
-      "reason": "SELECT lpad(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "lpad#fa432921a698/ansi_off",
       "reason": "SELECT lpad('hi', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -6929,14 +5337,6 @@
       "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#3011159f927e/ansi_off",
-      "reason": "SELECT ltrim(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "ltrim#3011159f927e/ansi_on",
-      "reason": "SELECT ltrim(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "ltrim#6225b3289404/ansi_off",
       "reason": "SELECT ltrim(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -6953,14 +5353,6 @@
       "id": "ltrim#866327adf4da/ansi_on",
       "reason": "SELECT ltrim(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "ltrim#9c6e39854838/ansi_off",
-      "reason": "SELECT ltrim(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "ltrim#9c6e39854838/ansi_on",
-      "reason": "SELECT ltrim(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "ltrim#a24ec608e9eb/ansi_off",
       "reason": "SELECT ltrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -7009,14 +5401,6 @@
       "id": "max#f536e65b0988/ansi_on",
       "reason": "SELECT max(col) FROM VALUES (10), (50), (20) AS tab(col) WHERE false | parse: KRISHIV_UNSUPPORTED_FEATURE: VALUES"
     },
-    {
-      "id": "md5#0133a4079c60/ansi_off",
-      "reason": "SELECT md5(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "md5#0133a4079c60/ansi_on",
-      "reason": "SELECT md5(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -7049,14 +5433,6 @@
       "id": "md5#a4ee2af175d3/ansi_on",
       "reason": "SELECT md5(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "md5#f6f8cc27374c/ansi_off",
-      "reason": "SELECT md5(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "md5#f6f8cc27374c/ansi_on",
-      "reason": "SELECT md5(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "md5#fd708175c7a6/ansi_off",
       "reason": "SELECT md5(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -7181,22 +5557,6 @@
       "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"
     },
-    {
-      "id": "mod#6aaa22528336/ansi_off",
-      "reason": "SELECT MOD(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1.8) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "mod#6aaa22528336/ansi_on",
-      "reason": "SELECT MOD(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1.8) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "mod#7b49d470ff35/ansi_off",
-      "reason": "SELECT MOD(TIMESTAMP'2024-02-29 12:34:56.123456', 1.8) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "mod#7b49d470ff35/ansi_on",
-      "reason": "SELECT MOD(TIMESTAMP'2024-02-29 12:34:56.123456', 1.8) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "mod#82d92a551fbf/ansi_off",
       "reason": "SELECT MOD(map('a', 1), 1.8) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -7217,14 +5577,6 @@
       "id": "mod#9d6e70dabb1b/ansi_off",
       "reason": "SELECT MOD(2, 'abc') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "mod#a66147f297dc/ansi_off",
-      "reason": "SELECT MOD(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "mod#a66147f297dc/ansi_on",
-      "reason": "SELECT MOD(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "mod#c02f1272d8d0/ansi_off",
       "reason": "SELECT MOD(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -7257,22 +5609,6 @@
       "id": "mod#d6971a885eed/ansi_on",
       "reason": "SELECT MOD(named_struct('a', 1, 'b', 'x'), 1.8) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "mod#ef4c7b84a22c/ansi_off",
-      "reason": "SELECT MOD(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "mod#ef4c7b84a22c/ansi_on",
-      "reason": "SELECT MOD(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "month#0707e1a44018/ansi_off",
-      "reason": "SELECT month(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "month#0707e1a44018/ansi_on",
-      "reason": "SELECT month(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "month#4d7a9771907c/ansi_off",
       "reason": "SELECT month(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -7313,22 +5649,6 @@
       "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"
     },
-    {
-      "id": "month#f0a19aaf971b/ansi_off",
-      "reason": "SELECT month(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "month#f0a19aaf971b/ansi_on",
-      "reason": "SELECT month(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "nanvl#18c6a12aa713/ansi_off",
-      "reason": "SELECT nanvl(cast('NaN' as double), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "nanvl#18c6a12aa713/ansi_on",
-      "reason": "SELECT nanvl(cast('NaN' as double), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "nanvl#1a9e2d1b0c49/ansi_off",
       "reason": "SELECT nanvl(cast('NaN' as double), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -7345,22 +5665,6 @@
       "id": "nanvl#224c752cdc8a/ansi_on",
       "reason": "SELECT nanvl(map('a', 1), 123) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "nanvl#22a5b5c63d69/ansi_off",
-      "reason": "SELECT nanvl(TIMESTAMP'2024-02-29 12:34:56.123456', 123) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "nanvl#22a5b5c63d69/ansi_on",
-      "reason": "SELECT nanvl(TIMESTAMP'2024-02-29 12:34:56.123456', 123) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "nanvl#3edf8fed4809/ansi_off",
-      "reason": "SELECT nanvl(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 123) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "nanvl#3edf8fed4809/ansi_on",
-      "reason": "SELECT nanvl(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 123) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -7401,14 +5705,6 @@
       "id": "nanvl#a3508ade0a62/ansi_on",
       "reason": "SELECT nanvl(named_struct('a', 1, 'b', 'x'), 123) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "nanvl#cbd1823d0323/ansi_off",
-      "reason": "SELECT nanvl(cast('NaN' as double), TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "nanvl#cbd1823d0323/ansi_on",
-      "reason": "SELECT nanvl(cast('NaN' as double), TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -7441,22 +5737,6 @@
       "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#295d759fbba2/ansi_off",
-      "reason": "SELECT negative(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "negative#295d759fbba2/ansi_on",
-      "reason": "SELECT negative(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "negative#72f0f7516c2d/ansi_off",
-      "reason": "SELECT negative(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "negative#72f0f7516c2d/ansi_on",
-      "reason": "SELECT negative(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "negative#987900a6d6ac/ansi_off",
       "reason": "SELECT negative(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -7705,14 +5985,6 @@
       "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#7abbb9486932/ansi_off",
-      "reason": "SELECT nullif(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullif#7abbb9486932/ansi_on",
-      "reason": "SELECT nullif(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "nullif#8c6ac4b1f807/ansi_off",
       "reason": "SELECT nullif(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -7729,22 +6001,6 @@
       "id": "nullif#9e38d7ab0840/ansi_on",
       "reason": "SELECT nullif(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "nullif#ab5281f7631e/ansi_off",
-      "reason": "SELECT nullif(TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullif#ab5281f7631e/ansi_on",
-      "reason": "SELECT nullif(TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullif#acd07f253876/ansi_off",
-      "reason": "SELECT nullif(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullif#acd07f253876/ansi_on",
-      "reason": "SELECT nullif(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "nullif#b1219b8ebaad/ansi_off",
       "reason": "SELECT nullif(INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -7769,14 +6025,6 @@
       "id": "nullif#dddf827b7218/ansi_on",
       "reason": "SELECT nullif(2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "nullif#e8717c9c7085/ansi_off",
-      "reason": "SELECT nullif(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullif#e8717c9c7085/ansi_on",
-      "reason": "SELECT nullif(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "nullif#f2b5a3646a34/ansi_off",
       "reason": "SELECT nullif(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -7817,14 +6065,6 @@
       "id": "nullifzero#b2fca9a991cf/ansi_on",
       "reason": "SELECT nullifzero(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "nullifzero#b8fcf25e8b61/ansi_off",
-      "reason": "SELECT nullifzero(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullifzero#b8fcf25e8b61/ansi_on",
-      "reason": "SELECT nullifzero(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -7833,14 +6073,6 @@
       "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#ccae65d0936a/ansi_off",
-      "reason": "SELECT nullifzero(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "nullifzero#ccae65d0936a/ansi_on",
-      "reason": "SELECT nullifzero(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "nullifzero#edaf27aa45a7/ansi_off",
       "reason": "SELECT nullifzero(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -7937,21 +6169,13 @@
       "id": "nvl#41a41efe1197/ansi_on",
       "reason": "SELECT nvl(NULL, CAST(NULL AS array<string>)) | parse: KRISHIV_UNSUPPORTED_FEATURE: nested data types (\"ARRAY\")"
     },
-    {
-      "id": "nvl#500ff688ab11/ansi_off",
-      "reason": "SELECT nvl(NULL, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "nvl#500ff688ab11/ansi_on",
-      "reason": "SELECT nvl(NULL, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "nvl#57346bea4d30/ansi_off",
-      "reason": "SELECT nvl(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "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_on",
-      "reason": "SELECT nvl(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "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_off",
@@ -8033,14 +6257,6 @@
       "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"
     },
-    {
-      "id": "nvl#bad617eca13b/ansi_off",
-      "reason": "SELECT nvl(NULL, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "nvl#bad617eca13b/ansi_on",
-      "reason": "SELECT nvl(NULL, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -8051,11 +6267,11 @@
     },
     {
       "id": "nvl#c72f6b63d89a/ansi_off",
-      "reason": "SELECT nvl(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "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_on",
-      "reason": "SELECT nvl(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
+      "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_off",
@@ -8129,14 +6345,6 @@
       "id": "nvl2#3c48eb611259/ansi_on",
       "reason": "SELECT nvl2(NULL, named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "nvl2#4006040e9920/ansi_off",
-      "reason": "SELECT nvl2(NULL, 2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl2#4006040e9920/ansi_on",
-      "reason": "SELECT nvl2(NULL, 2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -8193,30 +6401,6 @@
       "id": "nvl2#9987e2ffcc74/ansi_on",
       "reason": "SELECT nvl2(map('a', 1), 2, 1) | KRISHIV_UNSUPPORTED_FEATURE: function map"
     },
-    {
-      "id": "nvl2#9ee9915529a2/ansi_off",
-      "reason": "SELECT nvl2(NULL, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl2#9ee9915529a2/ansi_on",
-      "reason": "SELECT nvl2(NULL, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl2#a33cf4b512c0/ansi_off",
-      "reason": "SELECT nvl2(NULL, TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl2#a33cf4b512c0/ansi_on",
-      "reason": "SELECT nvl2(NULL, TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl2#b58c46561bc9/ansi_off",
-      "reason": "SELECT nvl2(TIMESTAMP'2024-02-29 12:34:56.123456', 2, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "nvl2#b58c46561bc9/ansi_on",
-      "reason": "SELECT nvl2(TIMESTAMP'2024-02-29 12:34:56.123456', 2, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "nvl2#b713cf78a1f7/ansi_off",
       "reason": "SELECT nvl2(NULL, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -8225,14 +6409,6 @@
       "id": "nvl2#b713cf78a1f7/ansi_on",
       "reason": "SELECT nvl2(NULL, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "nvl2#cc097eb69a1d/ansi_off",
-      "reason": "SELECT nvl2(NULL, 2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "nvl2#cc097eb69a1d/ansi_on",
-      "reason": "SELECT nvl2(NULL, 2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "id": "nvl2#ccee962457df/ansi_off",
       "reason": "SELECT nvl2(NULL, 2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
@@ -8257,14 +6433,6 @@
       "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#e6cfee518f69/ansi_off",
-      "reason": "SELECT nvl2(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "nvl2#e6cfee518f69/ansi_on",
-      "reason": "SELECT nvl2(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "nvl2#e7ae2541b711/ansi_off",
       "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"
@@ -8285,14 +6453,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#191fc9b7abb9/ansi_off",
-      "reason": "SELECT pmod(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "pmod#191fc9b7abb9/ansi_on",
-      "reason": "SELECT pmod(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -8337,22 +6497,6 @@
       "id": "pmod#4b50b5dc070f/ansi_off",
       "reason": "SELECT pmod('abc', 3) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "pmod#57164bce1972/ansi_off",
-      "reason": "SELECT pmod(10, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "pmod#57164bce1972/ansi_on",
-      "reason": "SELECT pmod(10, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "pmod#644e976fabf5/ansi_off",
-      "reason": "SELECT pmod(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "pmod#644e976fabf5/ansi_on",
-      "reason": "SELECT pmod(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "pmod#67660908fd02/ansi_off",
       "reason": "SELECT pmod(10, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -8369,14 +6513,6 @@
       "id": "pmod#7c89ed82b45b/ansi_off",
       "reason": "SELECT pmod(10, '1') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "pmod#94a399e6ed7f/ansi_off",
-      "reason": "SELECT pmod(10, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "pmod#94a399e6ed7f/ansi_on",
-      "reason": "SELECT pmod(10, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "pmod#aecf0980d9f7/ansi_off",
       "reason": "SELECT pmod(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
@@ -8409,14 +6545,6 @@
       "id": "pmod#f584bf262f44/ansi_on",
       "reason": "SELECT pmod(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "positive#039f0f770cd3/ansi_off",
-      "reason": "SELECT positive(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "positive#039f0f770cd3/ansi_on",
-      "reason": "SELECT positive(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -8425,14 +6553,6 @@
       "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#519a0219599c/ansi_off",
-      "reason": "SELECT positive(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "positive#519a0219599c/ansi_on",
-      "reason": "SELECT positive(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "positive#66e665f762a8/ansi_off",
       "reason": "SELECT positive(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -8481,14 +6601,6 @@
       "id": "pow#0ebc9f0c4365/ansi_on",
       "reason": "SELECT pow(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "pow#3f4239766132/ansi_off",
-      "reason": "SELECT pow(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "pow#3f4239766132/ansi_on",
-      "reason": "SELECT pow(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "pow#43948fbfbfd3/ansi_off",
       "reason": "SELECT pow(named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -8529,22 +6641,6 @@
       "id": "pow#9129c8ea381c/ansi_on",
       "reason": "SELECT pow(2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "pow#928c3a731d0d/ansi_off",
-      "reason": "SELECT pow(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "pow#928c3a731d0d/ansi_on",
-      "reason": "SELECT pow(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "pow#9beac80185f2/ansi_off",
-      "reason": "SELECT pow(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "pow#9beac80185f2/ansi_on",
-      "reason": "SELECT pow(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -8553,14 +6649,6 @@
       "id": "pow#a5c5256f4fbf/ansi_on",
       "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#b9f603dfc676/ansi_off",
-      "reason": "SELECT pow(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "pow#b9f603dfc676/ansi_on",
-      "reason": "SELECT pow(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -8585,14 +6673,6 @@
       "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#346fbde15f96/ansi_off",
-      "reason": "SELECT power(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "power#346fbde15f96/ansi_on",
-      "reason": "SELECT power(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "power#50aa498e03a3/ansi_off",
       "reason": "SELECT power(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -8649,14 +6729,6 @@
       "id": "power#d19c56950ea8/ansi_on",
       "reason": "SELECT power(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "power#d38933e3409c/ansi_off",
-      "reason": "SELECT power(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "power#d38933e3409c/ansi_on",
-      "reason": "SELECT power(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "power#daed4041da08/ansi_off",
       "reason": "SELECT power(2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -8665,14 +6737,6 @@
       "id": "power#daed4041da08/ansi_on",
       "reason": "SELECT power(2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "power#f3ee27f4d0b1/ansi_off",
-      "reason": "SELECT power(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "power#f3ee27f4d0b1/ansi_on",
-      "reason": "SELECT power(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "power#f93ad7c3e8b6/ansi_off",
       "reason": "SELECT power(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -8681,14 +6745,6 @@
       "id": "power#f93ad7c3e8b6/ansi_on",
       "reason": "SELECT power(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "power#fd32c0dcc235/ansi_off",
-      "reason": "SELECT power(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "power#fd32c0dcc235/ansi_on",
-      "reason": "SELECT power(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "radians#3eb311f55f31/ansi_off",
       "reason": "SELECT radians(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -8697,14 +6753,6 @@
       "id": "radians#3eb311f55f31/ansi_on",
       "reason": "SELECT radians(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "radians#495ffc2b5e51/ansi_off",
-      "reason": "SELECT radians(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "radians#495ffc2b5e51/ansi_on",
-      "reason": "SELECT radians(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -8721,14 +6769,6 @@
       "id": "radians#a6b560943a35/ansi_on",
       "reason": "SELECT radians(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "radians#bac807916572/ansi_off",
-      "reason": "SELECT radians(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "radians#bac807916572/ansi_on",
-      "reason": "SELECT radians(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "radians#de989828ff4d/ansi_off",
       "reason": "SELECT radians(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -8785,22 +6825,6 @@
       "id": "regexp#6659866add7c/ansi_on",
       "reason": "SELECT regexp('%SystemDrive%\\Users\\John', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "regexp#67d31682d598/ansi_off",
-      "reason": "SELECT regexp(TIMESTAMP'2024-02-29 12:34:56.123456', '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp#67d31682d598/ansi_on",
-      "reason": "SELECT regexp(TIMESTAMP'2024-02-29 12:34:56.123456', '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp#748b7c7362b9/ansi_off",
-      "reason": "SELECT regexp('%SystemDrive%\\Users\\John', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp#748b7c7362b9/ansi_on",
-      "reason": "SELECT regexp('%SystemDrive%\\Users\\John', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "regexp#75f562e9a5ab/ansi_off",
       "reason": "SELECT regexp(INTERVAL '1 02:03:04' DAY TO SECOND, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -8849,22 +6873,6 @@
       "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"
     },
-    {
-      "id": "regexp#f50cba0eb252/ansi_off",
-      "reason": "SELECT regexp(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp#f50cba0eb252/ansi_on",
-      "reason": "SELECT regexp(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp#ff7358cf46d4/ansi_off",
-      "reason": "SELECT regexp('%SystemDrive%\\Users\\John', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp#ff7358cf46d4/ansi_on",
-      "reason": "SELECT regexp('%SystemDrive%\\Users\\John', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -8873,14 +6881,6 @@
       "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#0965479a4260/ansi_off",
-      "reason": "SELECT regexp_count(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_count#0965479a4260/ansi_on",
-      "reason": "SELECT regexp_count(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "regexp_count#0afc8da34f72/ansi_off",
       "reason": "SELECT regexp_count(map('a', 1), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -8929,30 +6929,6 @@
       "id": "regexp_count#5d692adb9c66/ansi_on",
       "reason": "SELECT regexp_count(named_struct('a', 1, 'b', 'x'), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_count#61f9d5879d78/ansi_off",
-      "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_count#61f9d5879d78/ansi_on",
-      "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_count#6c6463b67079/ansi_off",
-      "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_count#6c6463b67079/ansi_on",
-      "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_count#a5306ef03b06/ansi_off",
-      "reason": "SELECT regexp_count(TIMESTAMP'2024-02-29 12:34:56.123456', 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_count#a5306ef03b06/ansi_on",
-      "reason": "SELECT regexp_count(TIMESTAMP'2024-02-29 12:34:56.123456', 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -8993,14 +6969,6 @@
       "id": "regexp_extract#17d1cf23ebb1/ansi_on",
       "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_extract#2c42b03814f3/ansi_off",
-      "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_extract#2c42b03814f3/ansi_on",
-      "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "regexp_extract#30b54cc8b365/ansi_off",
       "reason": "SELECT regexp_extract('100-200', INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -9041,14 +7009,6 @@
       "id": "regexp_extract#4d31ef6296af/ansi_on",
       "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_extract#51a5af26aeef/ansi_off",
-      "reason": "SELECT regexp_extract(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '(\\\\d+)-(\\\\d+)', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_extract#51a5af26aeef/ansi_on",
-      "reason": "SELECT regexp_extract(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '(\\\\d+)-(\\\\d+)', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -9065,14 +7025,6 @@
       "id": "regexp_extract#79c755b3b667/ansi_on",
       "reason": "SELECT regexp_extract(named_struct('a', 1, 'b', 'x'), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_extract#7f23cd648ea5/ansi_off",
-      "reason": "SELECT regexp_extract('100-200', TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_extract#7f23cd648ea5/ansi_on",
-      "reason": "SELECT regexp_extract('100-200', TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "regexp_extract#8abf01d909ed/ansi_off",
       "reason": "SELECT regexp_extract(INTERVAL '1-2' YEAR TO MONTH, '(\\\\d+)-(\\\\d+)', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -9105,14 +7057,6 @@
       "id": "regexp_extract#bbaba3d221ce/ansi_on",
       "reason": "SELECT regexp_extract('100-200', named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_extract#e26de6a3cb61/ansi_off",
-      "reason": "SELECT regexp_extract('100-200', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_extract#e26de6a3cb61/ansi_on",
-      "reason": "SELECT regexp_extract('100-200', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -9121,22 +7065,6 @@
       "id": "regexp_extract#e4b7e0aa5c1b/ansi_on",
       "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#e5dffb2a2b0c/ansi_off",
-      "reason": "SELECT regexp_extract(TIMESTAMP'2024-02-29 12:34:56.123456', '(\\\\d+)-(\\\\d+)', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_extract#e5dffb2a2b0c/ansi_on",
-      "reason": "SELECT regexp_extract(TIMESTAMP'2024-02-29 12:34:56.123456', '(\\\\d+)-(\\\\d+)', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_extract#fcf4d6cba0ab/ansi_off",
-      "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "regexp_extract#fcf4d6cba0ab/ansi_on",
-      "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -9177,22 +7105,6 @@
       "id": "regexp_instr#2faa36b849a1/ansi_on",
       "reason": "SELECT regexp_instr(r\"\\abc\", map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_instr#3617c6f1fc4e/ansi_off",
-      "reason": "SELECT regexp_instr(TIMESTAMP'2024-02-29 12:34:56.123456', r\"^\\\\abc$\") | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_instr#3617c6f1fc4e/ansi_on",
-      "reason": "SELECT regexp_instr(TIMESTAMP'2024-02-29 12:34:56.123456', r\"^\\\\abc$\") | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_instr#53563883dd91/ansi_off",
-      "reason": "SELECT regexp_instr(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', r\"^\\\\abc$\") | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_instr#53563883dd91/ansi_on",
-      "reason": "SELECT regexp_instr(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', r\"^\\\\abc$\") | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "regexp_instr#782bd946f194/ansi_off",
       "reason": "SELECT regexp_instr(r\"\\abc\", named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -9217,14 +7129,6 @@
       "id": "regexp_instr#a177fdc18858/ansi_on",
       "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#b75040d7ff90/ansi_off",
-      "reason": "SELECT regexp_instr(r\"\\abc\", TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_instr#b75040d7ff90/ansi_on",
-      "reason": "SELECT regexp_instr(r\"\\abc\", TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -9233,14 +7137,6 @@
       "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#e239a0d2f594/ansi_off",
-      "reason": "SELECT regexp_instr(r\"\\abc\", TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_instr#e239a0d2f594/ansi_on",
-      "reason": "SELECT regexp_instr(r\"\\abc\", TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -9266,52 +7162,20 @@
       "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
-      "id": "regexp_like#12e70fa5d0b4/ansi_off",
-      "reason": "SELECT regexp_like(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_like#12e70fa5d0b4/ansi_on",
-      "reason": "SELECT regexp_like(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_like#13bf747628ed/ansi_off",
-      "reason": "SELECT regexp_like(INTERVAL '1-2' YEAR TO MONTH, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "regexp_like#13bf747628ed/ansi_on",
-      "reason": "SELECT regexp_like(INTERVAL '1-2' YEAR TO MONTH, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "regexp_like#3c1582a99279/ansi_off",
-      "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_like#3c1582a99279/ansi_on",
-      "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_like#55ca391fec1c/ansi_off",
-      "reason": "SELECT regexp_like(INTERVAL '1 02:03:04' DAY TO SECOND, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "regexp_like#55ca391fec1c/ansi_on",
-      "reason": "SELECT regexp_like(INTERVAL '1 02:03:04' DAY TO SECOND, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
-    },
-    {
-      "id": "regexp_like#623a0f9dc12b/ansi_off",
-      "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "id": "regexp_like#13bf747628ed/ansi_off",
+      "reason": "SELECT regexp_like(INTERVAL '1-2' YEAR TO MONTH, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
-      "id": "regexp_like#623a0f9dc12b/ansi_on",
-      "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "id": "regexp_like#13bf747628ed/ansi_on",
+      "reason": "SELECT regexp_like(INTERVAL '1-2' YEAR TO MONTH, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
-      "id": "regexp_like#8452da8decec/ansi_off",
-      "reason": "SELECT regexp_like(TIMESTAMP'2024-02-29 12:34:56.123456', '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "id": "regexp_like#55ca391fec1c/ansi_off",
+      "reason": "SELECT regexp_like(INTERVAL '1 02:03:04' DAY TO SECOND, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
-      "id": "regexp_like#8452da8decec/ansi_on",
-      "reason": "SELECT regexp_like(TIMESTAMP'2024-02-29 12:34:56.123456', '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "id": "regexp_like#55ca391fec1c/ansi_on",
+      "reason": "SELECT regexp_like(INTERVAL '1 02:03:04' DAY TO SECOND, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "regexp_like#84a661eb1231/ansi_off",
@@ -9417,14 +7281,6 @@
       "id": "regexp_replace#4554f98913c4/ansi_on",
       "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#4ad2258a5586/ansi_off",
-      "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_replace#4ad2258a5586/ansi_on",
-      "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -9433,14 +7289,6 @@
       "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#636de4f3feba/ansi_off",
-      "reason": "SELECT regexp_replace(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '(\\\\d+)', 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_replace#636de4f3feba/ansi_on",
-      "reason": "SELECT regexp_replace(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '(\\\\d+)', 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "regexp_replace#69a3284260d7/ansi_off",
       "reason": "SELECT regexp_replace(named_struct('a', 1, 'b', 'x'), '(\\\\d+)', 'num') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -9457,14 +7305,6 @@
       "id": "regexp_replace#77d4f4ba5844/ansi_on",
       "reason": "SELECT regexp_replace('100-200', named_struct('a', 1, 'b', 'x'), 'num') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_replace#780d06e5d806/ansi_off",
-      "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_replace#780d06e5d806/ansi_on",
-      "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -9481,22 +7321,6 @@
       "id": "regexp_replace#7e9104eeb35d/ansi_on",
       "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "regexp_replace#95adbb11f099/ansi_off",
-      "reason": "SELECT regexp_replace(TIMESTAMP'2024-02-29 12:34:56.123456', '(\\\\d+)', 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_replace#95adbb11f099/ansi_on",
-      "reason": "SELECT regexp_replace(TIMESTAMP'2024-02-29 12:34:56.123456', '(\\\\d+)', 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_replace#99ef1ee4d285/ansi_off",
-      "reason": "SELECT regexp_replace('100-200', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_replace#99ef1ee4d285/ansi_on",
-      "reason": "SELECT regexp_replace('100-200', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "regexp_replace#d6194fc8a763/ansi_off",
       "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -9505,14 +7329,6 @@
       "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"
     },
-    {
-      "id": "regexp_replace#d837237c731c/ansi_off",
-      "reason": "SELECT regexp_replace('100-200', TIMESTAMP'2024-02-29 12:34:56.123456', 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_replace#d837237c731c/ansi_on",
-      "reason": "SELECT regexp_replace('100-200', TIMESTAMP'2024-02-29 12:34:56.123456', 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "regexp_replace#d882b6eb34c6/ansi_off",
       "reason": "SELECT regexp_replace('100-200', INTERVAL '1 02:03:04' DAY TO SECOND, 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -9545,14 +7361,6 @@
       "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#3863580221d9/ansi_off",
-      "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_substr#3863580221d9/ansi_on",
-      "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "regexp_substr#5cb59df0f0ef/ansi_off",
       "reason": "SELECT regexp_substr(INTERVAL '1-2' YEAR TO MONTH, 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -9561,14 +7369,6 @@
       "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"
     },
-    {
-      "id": "regexp_substr#6597365c5a90/ansi_off",
-      "reason": "SELECT regexp_substr(TIMESTAMP'2024-02-29 12:34:56.123456', 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_substr#6597365c5a90/ansi_on",
-      "reason": "SELECT regexp_substr(TIMESTAMP'2024-02-29 12:34:56.123456', 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "regexp_substr#77e7335bfb95/ansi_off",
       "reason": "SELECT regexp_substr(INTERVAL '1 02:03:04' DAY TO SECOND, 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -9593,14 +7393,6 @@
       "id": "regexp_substr#8231e7fc3dac/ansi_on",
       "reason": "SELECT regexp_substr('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_substr#8893fdead5eb/ansi_off",
-      "reason": "SELECT regexp_substr(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "regexp_substr#8893fdead5eb/ansi_on",
-      "reason": "SELECT regexp_substr(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -9641,22 +7433,6 @@
       "id": "regexp_substr#cd1b17330070/ansi_on",
       "reason": "SELECT regexp_substr('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"
     },
-    {
-      "id": "regexp_substr#ee608ae28a00/ansi_off",
-      "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "regexp_substr#ee608ae28a00/ansi_on",
-      "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "replace#19a6746c3d66/ansi_off",
-      "reason": "SELECT replace('ABCabc', 'abc', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "replace#19a6746c3d66/ansi_on",
-      "reason": "SELECT replace('ABCabc', 'abc', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "replace#1aa9e8eccba9/ansi_off",
       "reason": "SELECT replace(named_struct('a', 1, 'b', 'x'), 'abc', 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -9673,30 +7449,6 @@
       "id": "replace#1ead83cf0d2e/ansi_on",
       "reason": "SELECT replace('ABCabc', 'abc', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "replace#25a91e5b2099/ansi_off",
-      "reason": "SELECT replace('ABCabc', 'abc', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "replace#25a91e5b2099/ansi_on",
-      "reason": "SELECT replace('ABCabc', 'abc', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "replace#3ade46773f3d/ansi_off",
-      "reason": "SELECT replace(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'abc', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "replace#3ade46773f3d/ansi_on",
-      "reason": "SELECT replace(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'abc', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "replace#3d3bab1c18c5/ansi_off",
-      "reason": "SELECT replace('ABCabc', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "replace#3d3bab1c18c5/ansi_on",
-      "reason": "SELECT replace('ABCabc', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "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"
@@ -9713,14 +7465,6 @@
       "id": "replace#5c277e88fd2d/ansi_on",
       "reason": "SELECT replace('ABCabc', 'abc', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "replace#73aabe584815/ansi_off",
-      "reason": "SELECT replace(TIMESTAMP'2024-02-29 12:34:56.123456', 'abc', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "replace#73aabe584815/ansi_on",
-      "reason": "SELECT replace(TIMESTAMP'2024-02-29 12:34:56.123456', 'abc', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -9753,14 +7497,6 @@
       "id": "replace#8f3797458fc0/ansi_on",
       "reason": "SELECT replace(map('a', 1), 'abc', 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "replace#9bbb79d7dd74/ansi_off",
-      "reason": "SELECT replace('ABCabc', TIMESTAMP'2024-02-29 12:34:56.123456', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "replace#9bbb79d7dd74/ansi_on",
-      "reason": "SELECT replace('ABCabc', TIMESTAMP'2024-02-29 12:34:56.123456', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "replace#b4f9fb44df97/ansi_off",
       "reason": "SELECT replace('ABCabc', INTERVAL '1-2' YEAR TO MONTH, 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -9833,22 +7569,6 @@
       "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#8664f214dd09/ansi_off",
-      "reason": "SELECT rint(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rint#8664f214dd09/ansi_on",
-      "reason": "SELECT rint(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rint#86ec7312a72f/ansi_off",
-      "reason": "SELECT rint(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rint#86ec7312a72f/ansi_on",
-      "reason": "SELECT rint(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rint#baeea376e1af/ansi_off",
       "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"
@@ -9873,14 +7593,6 @@
       "id": "rint#eb2ae54d30a3/ansi_on",
       "reason": "SELECT rint(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "round#0d4f4c45de8c/ansi_off",
-      "reason": "SELECT round(TIMESTAMP'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "round#0d4f4c45de8c/ansi_on",
-      "reason": "SELECT round(TIMESTAMP'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "round#1420a7a45230/ansi_off",
       "reason": "SELECT round(2.5, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -9897,14 +7609,6 @@
       "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#25aaf119989a/ansi_off",
-      "reason": "SELECT round(2.5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "round#25aaf119989a/ansi_on",
-      "reason": "SELECT round(2.5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "round#286ac35a7044/ansi_off",
       "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"
@@ -9953,14 +7657,6 @@
       "id": "round#b34b11863015/ansi_on",
       "reason": "SELECT round(2.5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "round#b8d0c0f0d90a/ansi_off",
-      "reason": "SELECT round(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "round#b8d0c0f0d90a/ansi_on",
-      "reason": "SELECT round(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -9977,14 +7673,6 @@
       "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#fbd0b62ad90e/ansi_off",
-      "reason": "SELECT round(2.5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "round#fbd0b62ad90e/ansi_on",
-      "reason": "SELECT round(2.5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "row_number#d1083672f912/ansi_off",
       "reason": "SELECT a, b, row_number() OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | parse: KRISHIV_UNSUPPORTED_FEATURE: VALUES"
@@ -10065,14 +7753,6 @@
       "id": "rpad#2df795636485/ansi_on",
       "reason": "SELECT rpad('hi', 5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "rpad#2e73b3d05b7e/ansi_off",
-      "reason": "SELECT rpad('hi', TIMESTAMP'2024-02-29 12:34:56.123456', '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rpad#2e73b3d05b7e/ansi_on",
-      "reason": "SELECT rpad('hi', TIMESTAMP'2024-02-29 12:34:56.123456', '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rpad#2fe2afb03aa1/ansi_off",
       "reason": "SELECT hex(rpad(X'', 5)) | KRISHIV_UNSUPPORTED_FEATURE: function hex"
@@ -10105,14 +7785,6 @@
       "id": "rpad#3e212f5b728e/ansi_on",
       "reason": "SELECT hex(rpad(unhex('aabb'), 5, CAST(NULL AS binary))) | KRISHIV_UNSUPPORTED_FEATURE: function hex"
     },
-    {
-      "id": "rpad#4219877af42e/ansi_off",
-      "reason": "SELECT rpad('hi', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rpad#4219877af42e/ansi_on",
-      "reason": "SELECT rpad('hi', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -10137,14 +7809,6 @@
       "id": "rpad#6948ac2f6fa7/ansi_on",
       "reason": "SELECT rpad(named_struct('a', 1, 'b', 'x'), 5) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "rpad#6e7fe2886704/ansi_off",
-      "reason": "SELECT rpad('hi', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rpad#6e7fe2886704/ansi_on",
-      "reason": "SELECT rpad('hi', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rpad#7acc254d2875/ansi_off",
       "reason": "SELECT rpad(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10201,14 +7865,6 @@
       "id": "rpad#b7a6c3dd04b0/ansi_on",
       "reason": "SELECT rpad(INTERVAL '1-2' YEAR TO MONTH, 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "rpad#b8bc400fc2bf/ansi_off",
-      "reason": "SELECT rpad('hi', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "rpad#b8bc400fc2bf/ansi_on",
-      "reason": "SELECT rpad('hi', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "rpad#be2efa3ecda3/ansi_off",
       "reason": "SELECT hex(rpad(unhex('aabb'), 5, X'00FF7F80')) | KRISHIV_UNSUPPORTED_FEATURE: function hex"
@@ -10273,14 +7929,6 @@
       "id": "rpad#d13065615c15/ansi_on",
       "reason": "SELECT hex(rpad(unhex('aabb'), 5, unhex('1122'))) | KRISHIV_UNSUPPORTED_FEATURE: function hex"
     },
-    {
-      "id": "rpad#d49e5d4d3ea6/ansi_off",
-      "reason": "SELECT rpad('hi', 5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "rpad#d49e5d4d3ea6/ansi_on",
-      "reason": "SELECT rpad('hi', 5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "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"
@@ -10289,14 +7937,6 @@
       "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"
     },
-    {
-      "id": "rpad#dafd3b8b05de/ansi_off",
-      "reason": "SELECT rpad(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "rpad#dafd3b8b05de/ansi_on",
-      "reason": "SELECT rpad(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "rpad#e1759fee6985/ansi_off",
       "reason": "SELECT rpad(named_struct('a', 1, 'b', 'x'), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10313,38 +7953,6 @@
       "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#ea64e4be1f28/ansi_off",
-      "reason": "SELECT rpad(TIMESTAMP'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "rpad#ea64e4be1f28/ansi_on",
-      "reason": "SELECT rpad(TIMESTAMP'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "rpad#ef72516be6bf/ansi_off",
-      "reason": "SELECT rpad('hi', 5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "rpad#ef72516be6bf/ansi_on",
-      "reason": "SELECT rpad('hi', 5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "rpad#f1a4d2d1aeb2/ansi_off",
-      "reason": "SELECT rpad(TIMESTAMP'2024-02-29 12:34:56.123456', 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "rpad#f1a4d2d1aeb2/ansi_on",
-      "reason": "SELECT rpad(TIMESTAMP'2024-02-29 12:34:56.123456', 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "rpad#f1bd4487766c/ansi_off",
-      "reason": "SELECT rpad(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "rpad#f1bd4487766c/ansi_on",
-      "reason": "SELECT rpad(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "rpad#f3cf473e2510/ansi_off",
       "reason": "SELECT rpad(map('a', 1), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10369,14 +7977,6 @@
       "id": "rtrim#1737a0f2a2dc/ansi_on",
       "reason": "SELECT rtrim(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "rtrim#251d2a057833/ansi_off",
-      "reason": "SELECT rtrim(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "rtrim#251d2a057833/ansi_on",
-      "reason": "SELECT rtrim(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "rtrim#414ec50a8836/ansi_off",
       "reason": "SELECT rtrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10385,14 +7985,6 @@
       "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#43ce0ecc925b/ansi_off",
-      "reason": "SELECT rtrim(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "rtrim#43ce0ecc925b/ansi_on",
-      "reason": "SELECT rtrim(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "rtrim#4f1bf1caadb5/ansi_off",
       "reason": "SELECT rtrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10449,22 +8041,6 @@
       "id": "sec#c2e9bb28ade3/ansi_on",
       "reason": "SELECT sec(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sec#d31a3e0104ec/ansi_off",
-      "reason": "SELECT sec(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sec#d31a3e0104ec/ansi_on",
-      "reason": "SELECT sec(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sec#d63f6b0a4ae2/ansi_off",
-      "reason": "SELECT sec(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sec#d63f6b0a4ae2/ansi_on",
-      "reason": "SELECT sec(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -10489,14 +8065,6 @@
       "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#92226e23509d/ansi_off",
-      "reason": "SELECT sha(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha#92226e23509d/ansi_on",
-      "reason": "SELECT sha(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sha#a6b6487665d4/ansi_off",
       "reason": "SELECT sha(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10513,14 +8081,6 @@
       "id": "sha#d15102a86f23/ansi_on",
       "reason": "SELECT sha(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sha#d8d4932f8a07/ansi_off",
-      "reason": "SELECT sha(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha#d8d4932f8a07/ansi_on",
-      "reason": "SELECT sha(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sha#e797d848306b/ansi_off",
       "reason": "SELECT sha(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10545,22 +8105,6 @@
       "id": "sha1#186efaceecd5/ansi_on",
       "reason": "SELECT sha1(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sha1#6e55a39ec2d3/ansi_off",
-      "reason": "SELECT sha1(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha1#6e55a39ec2d3/ansi_on",
-      "reason": "SELECT sha1(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha1#86255e0777b0/ansi_off",
-      "reason": "SELECT sha1(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha1#86255e0777b0/ansi_on",
-      "reason": "SELECT sha1(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sha1#a28532e72e2a/ansi_off",
       "reason": "SELECT sha1(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10601,22 +8145,6 @@
       "id": "sha2#0d551c2bd461/ansi_on",
       "reason": "SELECT sha2(map('a', 1), 256) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sha2#1c5b7896f270/ansi_off",
-      "reason": "SELECT sha2('Spark', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha2#1c5b7896f270/ansi_on",
-      "reason": "SELECT sha2('Spark', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha2#3f138da6b0d1/ansi_off",
-      "reason": "SELECT sha2(TIMESTAMP'2024-02-29 12:34:56.123456', 256) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha2#3f138da6b0d1/ansi_on",
-      "reason": "SELECT sha2(TIMESTAMP'2024-02-29 12:34:56.123456', 256) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -10633,14 +8161,6 @@
       "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"
     },
-    {
-      "id": "sha2#682f1f887a20/ansi_off",
-      "reason": "SELECT sha2('Spark', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha2#682f1f887a20/ansi_on",
-      "reason": "SELECT sha2('Spark', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -10673,14 +8193,6 @@
       "id": "sha2#b5556c9204ad/ansi_on",
       "reason": "SELECT sha2('Spark', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sha2#cae7b50e9321/ansi_off",
-      "reason": "SELECT sha2(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 256) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sha2#cae7b50e9321/ansi_on",
-      "reason": "SELECT sha2(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 256) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sha2#e27329169b2b/ansi_off",
       "reason": "SELECT sha2(INTERVAL '1 02:03:04' DAY TO SECOND, 256) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10697,14 +8209,6 @@
       "id": "sha2#ff168ae5f3c1/ansi_on",
       "reason": "SELECT sha2(named_struct('a', 1, 'b', 'x'), 256) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sign#0250c0b17780/ansi_off",
-      "reason": "SELECT sign(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sign#0250c0b17780/ansi_on",
-      "reason": "SELECT sign(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -10761,22 +8265,6 @@
       "id": "sign#b5ebcde7d65f/ansi_on",
       "reason": "SELECT sign(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "sign#f88c875315b2/ansi_off",
-      "reason": "SELECT sign(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sign#f88c875315b2/ansi_on",
-      "reason": "SELECT sign(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "signum#1265aa020b00/ansi_off",
-      "reason": "SELECT signum(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "signum#1265aa020b00/ansi_on",
-      "reason": "SELECT signum(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "signum#1faf24081a60/ansi_off",
       "reason": "SELECT signum(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -10833,14 +8321,6 @@
       "id": "signum#d0d71adb94f9/ansi_on",
       "reason": "SELECT signum(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "signum#fcf919f15a38/ansi_off",
-      "reason": "SELECT signum(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "signum#fcf919f15a38/ansi_on",
-      "reason": "SELECT signum(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -10849,14 +8329,6 @@
       "id": "sin#07aad739ca7b/ansi_on",
       "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#2cbe7f02606e/ansi_off",
-      "reason": "SELECT sin(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sin#2cbe7f02606e/ansi_on",
-      "reason": "SELECT sin(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -10865,14 +8337,6 @@
       "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#5bb45b171001/ansi_off",
-      "reason": "SELECT sin(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sin#5bb45b171001/ansi_on",
-      "reason": "SELECT sin(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sin#6de2eba5fd5b/ansi_off",
       "reason": "SELECT sin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10897,14 +8361,6 @@
       "id": "sin#d008d5c5bf12/ansi_on",
       "reason": "SELECT sin(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sinh#1309d00a02dc/ansi_off",
-      "reason": "SELECT sinh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sinh#1309d00a02dc/ansi_on",
-      "reason": "SELECT sinh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sinh#474c20433f95/ansi_off",
       "reason": "SELECT sinh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10913,14 +8369,6 @@
       "id": "sinh#474c20433f95/ansi_on",
       "reason": "SELECT sinh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sinh#4b8c1e8fc5f2/ansi_off",
-      "reason": "SELECT sinh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sinh#4b8c1e8fc5f2/ansi_on",
-      "reason": "SELECT sinh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sinh#7f3e399ee823/ansi_off",
       "reason": "SELECT sinh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -10961,14 +8409,6 @@
       "id": "sqrt#16036e88e7c1/ansi_on",
       "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#373154890d47/ansi_off",
-      "reason": "SELECT sqrt(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sqrt#373154890d47/ansi_on",
-      "reason": "SELECT sqrt(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -10993,14 +8433,6 @@
       "id": "sqrt#609606380f2c/ansi_on",
       "reason": "SELECT sqrt(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "sqrt#c27c0d1a287f/ansi_off",
-      "reason": "SELECT sqrt(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "sqrt#c27c0d1a287f/ansi_on",
-      "reason": "SELECT sqrt(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "sqrt#eec06e7fff26/ansi_off",
       "reason": "SELECT sqrt(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -11057,22 +8489,6 @@
       "id": "startswith#41a1cdde2774/ansi_on",
       "reason": "SELECT startswith('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "startswith#7074793fd78c/ansi_off",
-      "reason": "SELECT startswith('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "startswith#7074793fd78c/ansi_on",
-      "reason": "SELECT startswith('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "startswith#893d72128c31/ansi_off",
-      "reason": "SELECT startswith(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "startswith#893d72128c31/ansi_on",
-      "reason": "SELECT startswith(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "startswith#89b90934ccfc/ansi_off",
       "reason": "SELECT startswith('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -11081,22 +8497,6 @@
       "id": "startswith#89b90934ccfc/ansi_on",
       "reason": "SELECT startswith('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "startswith#96203df3027f/ansi_off",
-      "reason": "SELECT startswith('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "startswith#96203df3027f/ansi_on",
-      "reason": "SELECT startswith('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "startswith#9a285e4a8959/ansi_off",
-      "reason": "SELECT startswith(TIMESTAMP'2024-02-29 12:34:56.123456', 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "startswith#9a285e4a8959/ansi_on",
-      "reason": "SELECT startswith(TIMESTAMP'2024-02-29 12:34:56.123456', 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "startswith#a3323368e4d6/ansi_off",
       "reason": "SELECT startswith(INTERVAL '1 02:03:04' DAY TO SECOND, 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -11161,14 +8561,6 @@
       "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#2270b877934c/ansi_off",
-      "reason": "SELECT substr('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#2270b877934c/ansi_on",
-      "reason": "SELECT substr('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substr#29ec6f65af26/ansi_off",
       "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"
@@ -11177,22 +8569,6 @@
       "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"
     },
-    {
-      "id": "substr#2f1b0319c806/ansi_off",
-      "reason": "SELECT substr(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "substr#2f1b0319c806/ansi_on",
-      "reason": "SELECT substr(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "substr#33aa48da2849/ansi_off",
-      "reason": "SELECT substr(TIMESTAMP'2024-02-29 12:34:56.123456', 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "substr#33aa48da2849/ansi_on",
-      "reason": "SELECT substr(TIMESTAMP'2024-02-29 12:34:56.123456', 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "substr#33fcc8cec89e/ansi_off",
       "reason": "SELECT substr(map('a', 1), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -11217,14 +8593,6 @@
       "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#6c0ba23eeec6/ansi_off",
-      "reason": "SELECT substr('Spark SQL', 5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#6c0ba23eeec6/ansi_on",
-      "reason": "SELECT substr('Spark SQL', 5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substr#723f8b45fc39/ansi_off",
       "reason": "SELECT substr('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -11249,22 +8617,6 @@
       "id": "substr#738183a8ca56/ansi_on",
       "reason": "SELECT substr(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substr#760148045e7e/ansi_off",
-      "reason": "SELECT substr('Spark SQL', 5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#760148045e7e/ansi_on",
-      "reason": "SELECT substr('Spark SQL', 5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#86f28e5347be/ansi_off",
-      "reason": "SELECT substr(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "substr#86f28e5347be/ansi_on",
-      "reason": "SELECT substr(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "substr#88aca1035a99/ansi_off",
       "reason": "SELECT substr('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"
@@ -11297,22 +8649,6 @@
       "id": "substr#95815c365de3/ansi_on",
       "reason": "SELECT substr(INTERVAL '1-2' YEAR TO MONTH, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "substr#96ffe4e60ba6/ansi_off",
-      "reason": "SELECT substr(TIMESTAMP'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "substr#96ffe4e60ba6/ansi_on",
-      "reason": "SELECT substr(TIMESTAMP'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "substr#9723ff5341f2/ansi_off",
-      "reason": "SELECT substr('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#9723ff5341f2/ansi_on",
-      "reason": "SELECT substr('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substr#9aaaa1965684/ansi_off",
       "reason": "SELECT substr('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -11353,22 +8689,6 @@
       "id": "substr#c4c789f9b7fb/ansi_on",
       "reason": "SELECT substr('Spark SQL', named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substr#d28dabc04c6b/ansi_off",
-      "reason": "SELECT substr('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#d28dabc04c6b/ansi_on",
-      "reason": "SELECT substr('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#d70ce6b2f9cf/ansi_off",
-      "reason": "SELECT substr('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substr#d70ce6b2f9cf/ansi_on",
-      "reason": "SELECT substr('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -11433,30 +8753,6 @@
       "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"
     },
-    {
-      "id": "substring#13d21dd5ea8a/ansi_off",
-      "reason": "SELECT substring('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#13d21dd5ea8a/ansi_on",
-      "reason": "SELECT substring('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#18724d311310/ansi_off",
-      "reason": "SELECT substring(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "substring#18724d311310/ansi_on",
-      "reason": "SELECT substring(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "substring#1912b486cf0d/ansi_off",
-      "reason": "SELECT substring(TIMESTAMP'2024-02-29 12:34:56.123456', 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "substring#1912b486cf0d/ansi_on",
-      "reason": "SELECT substring(TIMESTAMP'2024-02-29 12:34:56.123456', 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "substring#1cd62316c9ac/ansi_off",
       "reason": "SELECT substring('Spark SQL', 5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -11473,14 +8769,6 @@
       "id": "substring#28fa5bc39c1d/ansi_on",
       "reason": "SELECT substring(INTERVAL '1-2' YEAR TO MONTH, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "substring#2b99b9ff7cd7/ansi_off",
-      "reason": "SELECT substring(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "substring#2b99b9ff7cd7/ansi_on",
-      "reason": "SELECT substring(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "substring#36fb3fa04ab0/ansi_off",
       "reason": "SELECT substring('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -11529,14 +8817,6 @@
       "id": "substring#525e241ea7f0/ansi_on",
       "reason": "SELECT substring(INTERVAL '1-2' YEAR TO MONTH, 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "substring#5e535a40a6e6/ansi_off",
-      "reason": "SELECT substring('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#5e535a40a6e6/ansi_on",
-      "reason": "SELECT substring('Spark SQL', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -11593,14 +8873,6 @@
       "id": "substring#9dbbbb04884d/ansi_on",
       "reason": "SELECT substring(named_struct('a', 1, 'b', 'x'), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substring#b2b2f8cc66ea/ansi_off",
-      "reason": "SELECT substring('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#b2b2f8cc66ea/ansi_on",
-      "reason": "SELECT substring('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substring#bf20344accd7/ansi_off",
       "reason": "SELECT substring('Spark SQL', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -11609,14 +8881,6 @@
       "id": "substring#bf20344accd7/ansi_on",
       "reason": "SELECT substring('Spark SQL', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substring#c44dbab7b954/ansi_off",
-      "reason": "SELECT substring(TIMESTAMP'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "substring#c44dbab7b954/ansi_on",
-      "reason": "SELECT substring(TIMESTAMP'2024-02-29 12:34:56.123456', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "substring#c5ecd3ffb4a7/ansi_off",
       "reason": "SELECT substring('Spark SQL', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -11625,14 +8889,6 @@
       "id": "substring#c5ecd3ffb4a7/ansi_on",
       "reason": "SELECT substring('Spark SQL', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substring#c9ed73c56084/ansi_off",
-      "reason": "SELECT substring('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#c9ed73c56084/ansi_on",
-      "reason": "SELECT substring('Spark SQL', TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substring#cecac4e8ad77/ansi_off",
       "reason": "SELECT substring('Spark SQL', INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -11649,22 +8905,6 @@
       "id": "substring#d0a9e5313045/ansi_on",
       "reason": "SELECT substring('Spark SQL', map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "substring#dccc7c8904dd/ansi_off",
-      "reason": "SELECT substring('Spark SQL', 5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#dccc7c8904dd/ansi_on",
-      "reason": "SELECT substring('Spark SQL', 5, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#dd565e01d16a/ansi_off",
-      "reason": "SELECT substring('Spark SQL', 5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "substring#dd565e01d16a/ansi_on",
-      "reason": "SELECT substring('Spark SQL', 5, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "id": "substring#f4a34829cdcf/ansi_off",
       "reason": "SELECT substring('Spark SQL', named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -11769,22 +9009,6 @@
       "id": "tan#a3734f7996ca/ansi_on",
       "reason": "SELECT tan(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "tan#b939a577d35d/ansi_off",
-      "reason": "SELECT tan(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "tan#b939a577d35d/ansi_on",
-      "reason": "SELECT tan(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "tan#d06ed378e74c/ansi_off",
-      "reason": "SELECT tan(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "tan#d06ed378e74c/ansi_on",
-      "reason": "SELECT tan(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
     {
       "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"
@@ -11809,22 +9033,6 @@
       "id": "tanh#054342254ba1/ansi_on",
       "reason": "SELECT tanh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "tanh#78cf58ce7dc5/ansi_off",
-      "reason": "SELECT tanh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "tanh#78cf58ce7dc5/ansi_on",
-      "reason": "SELECT tanh(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "tanh#8fb5c6d9c384/ansi_off",
-      "reason": "SELECT tanh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
-    },
-    {
-      "id": "tanh#8fb5c6d9c384/ansi_on",
-      "reason": "SELECT tanh(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals 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"
@@ -11857,22 +9065,6 @@
       "id": "tanh#f8afd044650a/ansi_on",
       "reason": "SELECT tanh(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "trim#05ce9b712851/ansi_off",
-      "reason": "SELECT trim(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "trim#05ce9b712851/ansi_on",
-      "reason": "SELECT trim(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "trim#83796948bab1/ansi_off",
-      "reason": "SELECT trim(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "trim#83796948bab1/ansi_on",
-      "reason": "SELECT trim(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "trim#bd32121adee1/ansi_off",
       "reason": "SELECT trim(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -11923,11 +9115,11 @@
     },
     {
       "id": "try_add#06d82e68390e/ansi_off",
-      "reason": "SELECT try_add(1, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT try_add(1, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "try_add#06d82e68390e/ansi_on",
-      "reason": "SELECT try_add(1, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT try_add(1, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "try_add#07334485a510/ansi_off",
@@ -11939,19 +9131,19 @@
     },
     {
       "id": "try_add#0ff872af44be/ansi_off",
-      "reason": "SELECT try_add(timestamp'2021-01-01 00:00:00', CAST(NULL AS interval day)) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_add(timestamp'2021-01-01 00:00:00', CAST(NULL AS interval day)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
     },
     {
       "id": "try_add#0ff872af44be/ansi_on",
-      "reason": "SELECT try_add(timestamp'2021-01-01 00:00:00', CAST(NULL AS interval day)) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_add(timestamp'2021-01-01 00:00:00', CAST(NULL AS interval day)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
     },
     {
       "id": "try_add#1071be3465ad/ansi_off",
-      "reason": "SELECT try_add(TIMESTAMP'1969-12-31 23:59:59.999999', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_add(TIMESTAMP'1969-12-31 23:59:59.999999', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_add#1071be3465ad/ansi_on",
-      "reason": "SELECT try_add(TIMESTAMP'1969-12-31 23:59:59.999999', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_add(TIMESTAMP'1969-12-31 23:59:59.999999', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_add#20d5ec1fdf9e/ansi_off",
@@ -11967,11 +9159,11 @@
     },
     {
       "id": "try_add#4525b63c25fb/ansi_off",
-      "reason": "SELECT try_add(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT try_add(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "try_add#4525b63c25fb/ansi_on",
-      "reason": "SELECT try_add(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT try_add(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "try_add#48a77e2311d5/ansi_off",
@@ -12023,11 +9215,11 @@
     },
     {
       "id": "try_add#6174d3706f98/ansi_off",
-      "reason": "SELECT try_add(TIMESTAMP'2024-11-03 01:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_add(TIMESTAMP'2024-11-03 01:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_add#6174d3706f98/ansi_on",
-      "reason": "SELECT try_add(TIMESTAMP'2024-11-03 01:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_add(TIMESTAMP'2024-11-03 01:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_add#630ae7c41dd1/ansi_off",
@@ -12087,11 +9279,11 @@
     },
     {
       "id": "try_add#9e05d939ec33/ansi_off",
-      "reason": "SELECT try_add(TIMESTAMP'2024-03-10 02:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_add(TIMESTAMP'2024-03-10 02:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_add#9e05d939ec33/ansi_on",
-      "reason": "SELECT try_add(TIMESTAMP'2024-03-10 02:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_add(TIMESTAMP'2024-03-10 02:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_add#9fe84d8ef2fc/ansi_off",
@@ -12099,19 +9291,19 @@
     },
     {
       "id": "try_add#a1f70e66ffd8/ansi_off",
-      "reason": "SELECT try_add(TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT try_add(TIMESTAMP'2024-02-29 12:34:56.123456', 2) | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "try_add#a1f70e66ffd8/ansi_on",
-      "reason": "SELECT try_add(TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT try_add(TIMESTAMP'2024-02-29 12:34:56.123456', 2) | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "try_add#ac03293fc8cc/ansi_off",
-      "reason": "SELECT try_add(1, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT try_add(1, TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "try_add#ac03293fc8cc/ansi_on",
-      "reason": "SELECT try_add(1, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
+      "reason": "SELECT try_add(1, TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
     {
       "id": "try_add#b46c99769501/ansi_off",
@@ -12163,11 +9355,11 @@
     },
     {
       "id": "try_add#ea909325f05e/ansi_off",
-      "reason": "SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_add#ea909325f05e/ansi_on",
-      "reason": "SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_add#f593f3f19ebb/ansi_off",
@@ -12193,14 +9385,6 @@
       "id": "try_divide#438928ec5060/ansi_on",
       "reason": "SELECT try_divide(INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "try_divide#4773c959e372/ansi_off",
-      "reason": "SELECT try_divide(TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_divide#4773c959e372/ansi_on",
-      "reason": "SELECT try_divide(TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals 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"
@@ -12213,14 +9397,6 @@
       "id": "try_divide#5a3a4d187961/ansi_off",
       "reason": "SELECT try_divide('1', 2) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "try_divide#5b178f92bbd5/ansi_off",
-      "reason": "SELECT try_divide(3, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_divide#5b178f92bbd5/ansi_on",
-      "reason": "SELECT try_divide(3, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_divide#67b5387c6e04/ansi_off",
       "reason": "SELECT try_divide(interval 2 month, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -12289,22 +9465,6 @@
       "id": "try_divide#ac80a139ec15/ansi_on",
       "reason": "SELECT try_divide(3, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "try_divide#ba7f981857ac/ansi_off",
-      "reason": "SELECT try_divide(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_divide#ba7f981857ac/ansi_on",
-      "reason": "SELECT try_divide(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_divide#be367eefabc1/ansi_off",
-      "reason": "SELECT try_divide(3, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_divide#be367eefabc1/ansi_on",
-      "reason": "SELECT try_divide(3, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_divide#c6f73e490267/ansi_off",
       "reason": "SELECT try_divide(CAST(NULL AS interval month), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
@@ -12389,42 +9549,10 @@
       "id": "try_mod#61c91dfb3758/ansi_on",
       "reason": "SELECT try_mod(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "try_mod#7059f1b9ed70/ansi_off",
-      "reason": "SELECT try_mod(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_mod#7059f1b9ed70/ansi_on",
-      "reason": "SELECT try_mod(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_mod#717ca6f04521/ansi_off",
       "reason": "SELECT try_mod(3, 'abc') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "try_mod#7e4686f9e65d/ansi_off",
-      "reason": "SELECT try_mod(TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_mod#7e4686f9e65d/ansi_on",
-      "reason": "SELECT try_mod(TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_mod#85095b186666/ansi_off",
-      "reason": "SELECT try_mod(3, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_mod#85095b186666/ansi_on",
-      "reason": "SELECT try_mod(3, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_mod#86eb74221f59/ansi_off",
-      "reason": "SELECT try_mod(3, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_mod#86eb74221f59/ansi_on",
-      "reason": "SELECT try_mod(3, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_mod#951d8fe24b0b/ansi_off",
       "reason": "SELECT try_mod('abc', 2) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
@@ -12481,14 +9609,6 @@
       "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#2bb97ecd2dc7/ansi_off",
-      "reason": "SELECT try_multiply(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_multiply#2bb97ecd2dc7/ansi_on",
-      "reason": "SELECT try_multiply(TIMESTAMP'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_multiply#31933e3dbf90/ansi_off",
       "reason": "SELECT try_multiply(CAST(NULL AS interval year), 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
@@ -12521,14 +9641,6 @@
       "id": "try_multiply#4ad5e706ba92/ansi_on",
       "reason": "SELECT try_multiply(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
     },
-    {
-      "id": "try_multiply#5ee91d5cb642/ansi_off",
-      "reason": "SELECT try_multiply(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_multiply#5ee91d5cb642/ansi_on",
-      "reason": "SELECT try_multiply(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_multiply#602e46974789/ansi_off",
       "reason": "SELECT try_multiply(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -12545,14 +9657,6 @@
       "id": "try_multiply#66d96b95f6e8/ansi_on",
       "reason": "SELECT try_multiply(2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "try_multiply#6db18cf01a50/ansi_off",
-      "reason": "SELECT try_multiply(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_multiply#6db18cf01a50/ansi_on",
-      "reason": "SELECT try_multiply(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_multiply#74eb39d686d6/ansi_off",
       "reason": "SELECT try_multiply(2, '1') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
@@ -12593,14 +9697,6 @@
       "id": "try_multiply#f8aceea556aa/ansi_off",
       "reason": "SELECT try_multiply('abc', 3) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
     },
-    {
-      "id": "try_multiply#face234581d7/ansi_off",
-      "reason": "SELECT try_multiply(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
-    {
-      "id": "try_multiply#face234581d7/ansi_on",
-      "reason": "SELECT try_multiply(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES"
-    },
     {
       "id": "try_subtract#0edc9301ffa2/ansi_off",
       "reason": "SELECT try_subtract(2, '1') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off"
@@ -12615,19 +9711,19 @@
     },
     {
       "id": "try_subtract#170516e36186/ansi_off",
-      "reason": "SELECT try_subtract(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "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"
     },
     {
       "id": "try_subtract#170516e36186/ansi_on",
-      "reason": "SELECT try_subtract(2, TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "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"
     },
     {
       "id": "try_subtract#1722382e6981/ansi_off",
-      "reason": "SELECT try_subtract(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT try_subtract(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "try_subtract#1722382e6981/ansi_on",
-      "reason": "SELECT try_subtract(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT try_subtract(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 1) | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "try_subtract#1cae3483a411/ansi_off",
@@ -12639,11 +9735,11 @@
     },
     {
       "id": "try_subtract#264f43428b1b/ansi_off",
-      "reason": "SELECT try_subtract(TIMESTAMP'1969-12-31 23:59:59.999999', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_subtract(TIMESTAMP'1969-12-31 23:59:59.999999', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_subtract#264f43428b1b/ansi_on",
-      "reason": "SELECT try_subtract(TIMESTAMP'1969-12-31 23:59:59.999999', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_subtract(TIMESTAMP'1969-12-31 23:59:59.999999', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_subtract#2b174bd6e11e/ansi_off",
@@ -12687,11 +9783,11 @@
     },
     {
       "id": "try_subtract#4f7fb5ffdba9/ansi_off",
-      "reason": "SELECT try_subtract(TIMESTAMP'2024-11-03 01:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_subtract(TIMESTAMP'2024-11-03 01:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_subtract#4f7fb5ffdba9/ansi_on",
-      "reason": "SELECT try_subtract(TIMESTAMP'2024-11-03 01:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_subtract(TIMESTAMP'2024-11-03 01:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_subtract#6ab14af75051/ansi_off",
@@ -12767,27 +9863,27 @@
     },
     {
       "id": "try_subtract#a275842dc947/ansi_off",
-      "reason": "SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_subtract#a275842dc947/ansi_on",
-      "reason": "SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_subtract#b3a2ebb279d1/ansi_off",
-      "reason": "SELECT try_subtract(timestamp'2021-01-02 00:00:00', CAST(NULL AS interval day)) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_subtract(timestamp'2021-01-02 00:00:00', CAST(NULL AS interval day)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
     },
     {
       "id": "try_subtract#b3a2ebb279d1/ansi_on",
-      "reason": "SELECT try_subtract(timestamp'2021-01-02 00:00:00', CAST(NULL AS interval day)) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_subtract(timestamp'2021-01-02 00:00:00', CAST(NULL AS interval day)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")"
     },
     {
       "id": "try_subtract#b47d28681499/ansi_off",
-      "reason": "SELECT try_subtract(TIMESTAMP'2024-03-10 02:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_subtract(TIMESTAMP'2024-03-10 02:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_subtract#b47d28681499/ansi_on",
-      "reason": "SELECT try_subtract(TIMESTAMP'2024-03-10 02:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT try_subtract(TIMESTAMP'2024-03-10 02:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
     {
       "id": "try_subtract#b9b03d11040b/ansi_off",
@@ -12799,11 +9895,11 @@
     },
     {
       "id": "try_subtract#c6ab435c35e2/ansi_off",
-      "reason": "SELECT try_subtract(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT try_subtract(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "try_subtract#c6ab435c35e2/ansi_on",
-      "reason": "SELECT try_subtract(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT try_subtract(2, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "try_subtract#cf94932b9ee9/ansi_off",
@@ -12843,11 +9939,11 @@
     },
     {
       "id": "try_subtract#f2cd0274bcdc/ansi_off",
-      "reason": "SELECT try_subtract(TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT try_subtract(TIMESTAMP'2024-02-29 12:34:56.123456', 1) | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "try_subtract#f2cd0274bcdc/ansi_on",
-      "reason": "SELECT try_subtract(TIMESTAMP'2024-02-29 12:34:56.123456', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
+      "reason": "SELECT try_subtract(TIMESTAMP'2024-02-29 12:34:56.123456', 1) | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
     {
       "id": "try_subtract#f6e4926b7d7b/ansi_off",
@@ -12889,14 +9985,6 @@
       "id": "ucase#9de2d667346e/ansi_on",
       "reason": "SELECT ucase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "ucase#c671b9c228ec/ansi_off",
-      "reason": "SELECT ucase(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "ucase#c671b9c228ec/ansi_on",
-      "reason": "SELECT ucase(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "ucase#d170ded41cbd/ansi_off",
       "reason": "SELECT ucase(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -12913,14 +10001,6 @@
       "id": "ucase#eddc7fabde57/ansi_on",
       "reason": "SELECT ucase(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "ucase#f423f6d33f56/ansi_off",
-      "reason": "SELECT ucase(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "ucase#f423f6d33f56/ansi_on",
-      "reason": "SELECT ucase(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "upper#04b381e12869/ansi_off",
       "reason": "SELECT upper(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -12937,14 +10017,6 @@
       "id": "upper#22f819e17e9b/ansi_on",
       "reason": "SELECT upper(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
     },
-    {
-      "id": "upper#27474c18f717/ansi_off",
-      "reason": "SELECT upper(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "upper#27474c18f717/ansi_on",
-      "reason": "SELECT upper(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "upper#753d2b0105f9/ansi_off",
       "reason": "SELECT upper(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -12953,14 +10025,6 @@
       "id": "upper#753d2b0105f9/ansi_on",
       "reason": "SELECT upper(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
     },
-    {
-      "id": "upper#90576e737851/ansi_off",
-      "reason": "SELECT upper(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "upper#90576e737851/ansi_on",
-      "reason": "SELECT upper(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "upper#a8ece98a87b6/ansi_off",
       "reason": "SELECT upper(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -13027,11 +10091,11 @@
     },
     {
       "id": "xxhash64#1c0a6e612b22/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "xxhash64#1c0a6e612b22/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "xxhash64#262bbf2d0fc5/ansi_off",
@@ -13083,19 +10147,19 @@
     },
     {
       "id": "xxhash64#3ca12993a520/ansi_off",
-      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
+      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "xxhash64#3ca12993a520/ansi_on",
-      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
+      "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "xxhash64#3ebf8dfbd92e/ansi_off",
-      "reason": "SELECT xxhash64(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT xxhash64(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "xxhash64#3ebf8dfbd92e/ansi_on",
-      "reason": "SELECT xxhash64(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "SELECT xxhash64(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "xxhash64#3ed299546ff7/ansi_off",
@@ -13121,14 +10185,6 @@
       "id": "xxhash64#4de68e47e367/ansi_on",
       "reason": "SELECT xxhash64('', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
-    {
-      "id": "xxhash64#53004aaebe7c/ansi_off",
-      "reason": "SELECT xxhash64('Spark', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "xxhash64#53004aaebe7c/ansi_on",
-      "reason": "SELECT xxhash64('Spark', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "xxhash64#5b1bb149749b/ansi_off",
       "reason": "SELECT xxhash64(1, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
@@ -13273,14 +10329,6 @@
       "id": "xxhash64#a4386f4089b0/ansi_on",
       "reason": "SELECT xxhash64(NULL, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
-    {
-      "id": "xxhash64#a798b8180ea7/ansi_off",
-      "reason": "SELECT xxhash64('Spark', TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "xxhash64#a798b8180ea7/ansi_on",
-      "reason": "SELECT xxhash64('Spark', TIMESTAMP'2024-02-29 12:34:56.123456', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "xxhash64#aa4cafed551d/ansi_off",
       "reason": "SELECT xxhash64('Spark', INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals"
@@ -13355,11 +10403,11 @@
     },
     {
       "id": "xxhash64#da904e59abfa/ansi_off",
-      "reason": "SELECT xxhash64(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
+      "reason": "SELECT xxhash64(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | 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) | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
+      "reason": "SELECT xxhash64(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
     {
       "id": "xxhash64#dd7cffaf7f2d/ansi_off",
@@ -13465,14 +10513,6 @@
       "id": "xxhash64#fb104518ccd7/ansi_on",
       "reason": "SELECT xxhash64(array(1, 2), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array"
     },
-    {
-      "id": "year#0df2a61c0f91/ansi_off",
-      "reason": "SELECT year(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
-    {
-      "id": "year#0df2a61c0f91/ansi_on",
-      "reason": "SELECT year(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals"
-    },
     {
       "id": "year#34c36afe6dce/ansi_off",
       "reason": "SELECT year(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -13489,14 +10529,6 @@
       "id": "year#64d0616f8b51/ansi_on",
       "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#781973e09a14/ansi_off",
-      "reason": "SELECT year(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
-    {
-      "id": "year#781973e09a14/ansi_on",
-      "reason": "SELECT year(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
-    },
     {
       "id": "year#98b02509736a/ansi_off",
       "reason": "SELECT year(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"
@@ -13529,14 +10561,6 @@
       "id": "zeroifnull#05644a809fb4/ansi_on",
       "reason": "SELECT zeroifnull(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     },
-    {
-      "id": "zeroifnull#316af7382fbe/ansi_off",
-      "reason": "SELECT zeroifnull(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "zeroifnull#316af7382fbe/ansi_on",
-      "reason": "SELECT zeroifnull(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP_NTZ literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
     {
       "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"
@@ -13568,14 +10592,6 @@
     {
       "id": "zeroifnull#da0e05d51fd1/ansi_on",
       "reason": "SELECT zeroifnull(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "zeroifnull#e9f715e24280/ansi_off",
-      "reason": "SELECT zeroifnull(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
-    },
-    {
-      "id": "zeroifnull#e9f715e24280/ansi_on",
-      "reason": "SELECT zeroifnull(TIMESTAMP'2024-02-29 12:34:56.123456') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES"
     }
   ],
   "format_version": 1,
@@ -13583,42 +10599,42 @@
     {
       "cases": 54,
       "function": "abs",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "acos",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "acosh",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 52,
       "function": "asin",
-      "pass": 38
+      "pass": 42
     },
     {
       "cases": 50,
       "function": "asinh",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "atan",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 98,
       "function": "atan2",
-      "pass": 70
+      "pass": 78
     },
     {
       "cases": 52,
       "function": "atanh",
-      "pass": 38
+      "pass": 42
     },
     {
       "cases": 10,
@@ -13628,62 +10644,62 @@
     {
       "cases": 106,
       "function": "bround",
-      "pass": 78
+      "pass": 86
     },
     {
       "cases": 182,
       "function": "btrim",
-      "pass": 124
+      "pass": 136
     },
     {
       "cases": 50,
       "function": "cbrt",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 158,
       "function": "ceil",
-      "pass": 116
+      "pass": 128
     },
     {
       "cases": 158,
       "function": "ceiling",
-      "pass": 116
+      "pass": 128
     },
     {
       "cases": 66,
       "function": "char_length",
-      "pass": 52
+      "pass": 56
     },
     {
       "cases": 66,
       "function": "character_length",
-      "pass": 52
+      "pass": 56
     },
     {
       "cases": 128,
       "function": "coalesce",
-      "pass": 86
+      "pass": 98
     },
     {
       "cases": 124,
       "function": "contains",
-      "pass": 96
+      "pass": 104
     },
     {
       "cases": 50,
       "function": "cos",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "cosh",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 48,
       "function": "cot",
-      "pass": 34
+      "pass": 38
     },
     {
       "cases": 12,
@@ -13693,12 +10709,12 @@
     {
       "cases": 54,
       "function": "crc32",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 48,
       "function": "csc",
-      "pass": 34
+      "pass": 38
     },
     {
       "cases": 2,
@@ -13728,47 +10744,47 @@
     {
       "cases": 100,
       "function": "date_add",
-      "pass": 72
+      "pass": 80
     },
     {
       "cases": 108,
       "function": "date_diff",
-      "pass": 80
+      "pass": 88
     },
     {
       "cases": 134,
       "function": "date_part",
-      "pass": 40
+      "pass": 96
     },
     {
       "cases": 100,
       "function": "date_sub",
-      "pass": 72
+      "pass": 80
     },
     {
       "cases": 100,
       "function": "dateadd",
-      "pass": 72
+      "pass": 80
     },
     {
       "cases": 108,
       "function": "datediff",
-      "pass": 80
+      "pass": 88
     },
     {
       "cases": 54,
       "function": "day",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 54,
       "function": "dayofmonth",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 50,
       "function": "degrees",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 2,
@@ -13783,22 +10799,22 @@
     {
       "cases": 126,
       "function": "endswith",
-      "pass": 98
+      "pass": 106
     },
     {
       "cases": 50,
       "function": "exp",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "expm1",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 22,
       "function": "extract",
-      "pass": 2
+      "pass": 8
     },
     {
       "cases": 54,
@@ -13813,32 +10829,32 @@
     {
       "cases": 158,
       "function": "floor",
-      "pass": 116
+      "pass": 128
     },
     {
       "cases": 242,
       "function": "greatest",
-      "pass": 172
+      "pass": 192
     },
     {
       "cases": 150,
       "function": "hash",
-      "pass": 28
+      "pass": 32
     },
     {
       "cases": 98,
       "function": "hypot",
-      "pass": 70
+      "pass": 78
     },
     {
       "cases": 150,
       "function": "if",
-      "pass": 108
+      "pass": 120
     },
     {
       "cases": 90,
       "function": "ifnull",
-      "pass": 28
+      "pass": 32
     },
     {
       "cases": 54,
@@ -13853,22 +10869,22 @@
     {
       "cases": 54,
       "function": "lcase",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 242,
       "function": "least",
-      "pass": 172
+      "pass": 192
     },
     {
       "cases": 66,
       "function": "length",
-      "pass": 52
+      "pass": 56
     },
     {
       "cases": 48,
       "function": "ln",
-      "pass": 34
+      "pass": 38
     },
     {
       "cases": 2,
@@ -13878,37 +10894,37 @@
     {
       "cases": 98,
       "function": "log",
-      "pass": 70
+      "pass": 78
     },
     {
       "cases": 50,
       "function": "log10",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "log1p",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "log2",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 54,
       "function": "lower",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 270,
       "function": "lpad",
-      "pass": 178
+      "pass": 198
     },
     {
       "cases": 54,
       "function": "ltrim",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 8,
@@ -13918,7 +10934,7 @@
     {
       "cases": 54,
       "function": "md5",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 10,
@@ -13933,22 +10949,22 @@
     {
       "cases": 100,
       "function": "mod",
-      "pass": 68
+      "pass": 76
     },
     {
       "cases": 54,
       "function": "month",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 102,
       "function": "nanvl",
-      "pass": 74
+      "pass": 82
     },
     {
       "cases": 48,
       "function": "negative",
-      "pass": 34
+      "pass": 38
     },
     {
       "cases": 2,
@@ -13963,22 +10979,22 @@
     {
       "cases": 98,
       "function": "nullif",
-      "pass": 70
+      "pass": 78
     },
     {
       "cases": 52,
       "function": "nullifzero",
-      "pass": 38
+      "pass": 42
     },
     {
       "cases": 90,
       "function": "nvl",
-      "pass": 28
+      "pass": 32
     },
     {
       "cases": 136,
       "function": "nvl2",
-      "pass": 94
+      "pass": 106
     },
     {
       "cases": 2,
@@ -13993,27 +11009,27 @@
     {
       "cases": 100,
       "function": "pmod",
-      "pass": 68
+      "pass": 76
     },
     {
       "cases": 48,
       "function": "positive",
-      "pass": 34
+      "pass": 38
     },
     {
       "cases": 98,
       "function": "pow",
-      "pass": 70
+      "pass": 78
     },
     {
       "cases": 98,
       "function": "power",
-      "pass": 70
+      "pass": 78
     },
     {
       "cases": 50,
       "function": "radians",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 2,
@@ -14023,52 +11039,52 @@
     {
       "cases": 110,
       "function": "regexp",
-      "pass": 82
+      "pass": 90
     },
     {
       "cases": 108,
       "function": "regexp_count",
-      "pass": 80
+      "pass": 88
     },
     {
       "cases": 154,
       "function": "regexp_extract",
-      "pass": 112
+      "pass": 124
     },
     {
       "cases": 108,
       "function": "regexp_instr",
-      "pass": 80
+      "pass": 88
     },
     {
       "cases": 110,
       "function": "regexp_like",
-      "pass": 82
+      "pass": 90
     },
     {
       "cases": 160,
       "function": "regexp_replace",
-      "pass": 118
+      "pass": 130
     },
     {
       "cases": 108,
       "function": "regexp_substr",
-      "pass": 80
+      "pass": 88
     },
     {
       "cases": 156,
       "function": "replace",
-      "pass": 114
+      "pass": 126
     },
     {
       "cases": 50,
       "function": "rint",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 98,
       "function": "round",
-      "pass": 70
+      "pass": 78
     },
     {
       "cases": 2,
@@ -14078,17 +11094,17 @@
     {
       "cases": 270,
       "function": "rpad",
-      "pass": 178
+      "pass": 198
     },
     {
       "cases": 54,
       "function": "rtrim",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 50,
       "function": "sec",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 2,
@@ -14098,57 +11114,57 @@
     {
       "cases": 54,
       "function": "sha",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 54,
       "function": "sha1",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 102,
       "function": "sha2",
-      "pass": 74
+      "pass": 82
     },
     {
       "cases": 54,
       "function": "sign",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 54,
       "function": "signum",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "sin",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "sinh",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "sqrt",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 126,
       "function": "startswith",
-      "pass": 98
+      "pass": 106
     },
     {
       "cases": 266,
       "function": "substr",
-      "pass": 194
+      "pass": 214
     },
     {
       "cases": 266,
       "function": "substring",
-      "pass": 194
+      "pass": 214
     },
     {
       "cases": 12,
@@ -14158,17 +11174,17 @@
     {
       "cases": 50,
       "function": "tan",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 50,
       "function": "tanh",
-      "pass": 36
+      "pass": 40
     },
     {
       "cases": 68,
       "function": "trim",
-      "pass": 54
+      "pass": 58
     },
     {
       "cases": 128,
@@ -14178,17 +11194,17 @@
     {
       "cases": 120,
       "function": "try_divide",
-      "pass": 82
+      "pass": 90
     },
     {
       "cases": 128,
       "function": "try_mod",
-      "pass": 96
+      "pass": 104
     },
     {
       "cases": 104,
       "function": "try_multiply",
-      "pass": 68
+      "pass": 76
     },
     {
       "cases": 128,
@@ -14198,12 +11214,12 @@
     {
       "cases": 54,
       "function": "ucase",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 54,
       "function": "upper",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 2,
@@ -14213,18 +11229,18 @@
     {
       "cases": 150,
       "function": "xxhash64",
-      "pass": 28
+      "pass": 32
     },
     {
       "cases": 54,
       "function": "year",
-      "pass": 40
+      "pass": 44
     },
     {
       "cases": 50,
       "function": "zeroifnull",
-      "pass": 36
+      "pass": 40
     }
   ],
-  "pass": 6618
+  "pass": 7364
 }
diff --git a/tests/fixtures/analysis/type-coercion-manifest.json b/tests/fixtures/analysis/type-coercion-manifest.json
index 54707703..727b1e6d 100644
--- a/tests/fixtures/analysis/type-coercion-manifest.json
+++ b/tests/fixtures/analysis/type-coercion-manifest.json
@@ -48,7 +48,7 @@
     {
       "file": "typeCoercion/native/arrayJoin",
       "query": "SELECT array_join(array(timestamp '2016-11-15 20:54:00.000', timestamp '2016-11-12 20:54:00.000'), ', ')",
-      "reason": "KRISHIV_UNSUPPORTED_FEATURE: TIMESTAMP literals"
+      "reason": "KRISHIV_UNSUPPORTED_FEATURE: function array_join"
     },
     {
       "file": "typeCoercion/native/arrayJoin",