From ac532cd44e205ee1c142f54b7823e0a27442a362 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Fri, 23 Oct 2026 16:55:28 +0200 Subject: [PATCH 1/4] Support typed timestamp literals via CAST kernels Spark accepts TIMESTAMP '...', TIMESTAMP_LTZ '...', TIMESTAMP_NTZ '...' and DATE '...' typed literals. Krishiv parsed them but rejected the TIMESTAMP forms when lowering, forcing workarounds with CAST instead. Parsing stays in the existing literal grammar. Lowering now evaluates timestamp literals once at analysis time through the same CAST string-to-timestamp kernels execution uses, so parsing rules match CAST. Plain TIMESTAMP follows spark.sql.timestampType (without a zone it is TIMESTAMP_NTZ, with a zone it stays an instant) and instants without a zone read spark.sql.session.timeZone. The result is a constant Literal, never a per-row cast. Malformed text fails with INVALID_TYPED_LITERAL at the literal span; clock-dependent spellings (now, today, bare times) and region zones needing the tz database stay KRISHIV_UNSUPPORTED_FEATURE, as the kernels report. Output names now render timestamp literals as Spark does (TIMESTAMP '...' / TIMESTAMP_NTZ '...'). Unverified: region-zone session rows against the goldens (the engine has no tz database, as for CASTs); TIME and INTERVAL typed forms remain unsupported, as the IR has no such types. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- Cargo.lock | 2 + crates/krishiv-plan/src/analyzer/exprs.rs | 50 +++++ crates/krishiv-session/src/explain.rs | 7 +- crates/krishiv-session/src/session.rs | 6 +- crates/krishiv-sql/Cargo.toml | 2 + crates/krishiv-sql/src/frontend.rs | 13 +- crates/krishiv-sql/src/lib.rs | 27 +++ crates/krishiv-sql/src/lower.rs | 206 +++++++++++++++++- crates/krishiv-sql/src/tests.rs | 133 +++++++++++ crates/krishiv-sql/src/validate/literal.rs | 2 +- crates/krishiv-sql/tests/analyzer.rs | 69 ++++++ ...cts_lower_or_are_named_as_unsupported.snap | 2 +- 12 files changed, 505 insertions(+), 14 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7a66e93b..9e2ba81a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1740,6 +1740,8 @@ version = "0.1.0-alpha" name = "krishiv-sql" version = "0.1.0-alpha" dependencies = [ + "arrow-array", + "arrow-schema", "codspeed-criterion-compat", "insta", "krishiv-common", diff --git a/crates/krishiv-plan/src/analyzer/exprs.rs b/crates/krishiv-plan/src/analyzer/exprs.rs index 045f9b34..595f4a7e 100644 --- a/crates/krishiv-plan/src/analyzer/exprs.rs +++ b/crates/krishiv-plan/src/analyzer/exprs.rs @@ -1687,10 +1687,60 @@ fn pretty_literal(v: &Literal) -> String { Literal::Float(x) => format!("{x:?}"), Literal::Double(x) => format!("{x:?}"), Literal::Decimal { .. } => text.trim_end_matches("BD").to_owned(), + // Spark's `toPrettySQL` of a timestamp literal, in the session zone. + // Lowering evaluates session-independent values (and session ones in + // a fixed-offset zone) with the kernels and formats here in UTC; + // values without a zone read the same either way, so names match + // Spark's for them. + Literal::Timestamp(us) => format!("TIMESTAMP '{}'", format_timestamp(*us)), + Literal::TimestampNtz(us) => format!("TIMESTAMP_NTZ '{}'", format_timestamp(*us)), _ => text, } } +/// Microseconds since the epoch as `yyyy-MM-dd HH:mm:ss[.fraction]`, the +/// proleptic Gregorian date (as Spark prints a timestamp literal). +fn format_timestamp(micros: i64) -> String { + const MICROS_PER_DAY: i64 = 86_400_000_000; + const MICROS_PER_SECOND: i64 = 1_000_000; + let days = micros.div_euclid(MICROS_PER_DAY); + let rest = micros.rem_euclid(MICROS_PER_DAY); + let (y, m, d) = civil_from_days(days); + let sign = if y < 0 { "-" } else { "" }; + let mut out = format!("{sign}{:04}-{:02}-{:02}", y.unsigned_abs(), m, d); + let secs = rest / MICROS_PER_SECOND; + let frac = rest % MICROS_PER_SECOND; + { + use std::fmt::Write as _; + let _ = write!( + &mut out, + " {:02}:{:02}:{:02}", + secs / 3600, + secs / 60 % 60, + secs % 60 + ); + if frac != 0 { + let digits = format!("{frac:06}"); + let _ = write!(&mut out, ".{}", digits.trim_end_matches('0')); + } + } + out +} + +/// `(year, month, day)` of a day number (H. Hinnant's `civil_from_days`). +fn civil_from_days(days: i64) -> (i64, i64, i64) { + let z = days + 719_468; + let era = z.div_euclid(146_097); + let doe = z.rem_euclid(146_097); + let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; + let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); + let mp = (5 * doy + 2) / 153; + let day = doy - (153 * mp + 2) / 5 + 1; + let month = if mp < 10 { mp + 3 } else { mp - 9 }; + let year = yoe + era * 400 + i64::from(month <= 2); + (year, month, day) +} + /// A semantic key: equal for expressions that compute the same value, /// whatever their origins, column spellings or (top-level) alias. pub(super) fn semantic_key(e: &Expr, memo: &mut HashMap) -> u128 { diff --git a/crates/krishiv-session/src/explain.rs b/crates/krishiv-session/src/explain.rs index 3f741d91..52c4b681 100644 --- a/crates/krishiv-session/src/explain.rs +++ b/crates/krishiv-session/src/explain.rs @@ -53,7 +53,9 @@ impl Session { } .into()); }; - let plan = krishiv_sql::lower(q, krishiv_plan::SourceId(0)).map_err(|e| e.error)?; + let env = self.query_env(); + let plan = + krishiv_sql::lower(q, krishiv_plan::SourceId(0), &env.parser).map_err(|e| e.error)?; let explained = DataFrame::new(self.clone(), Arc::clone(plan.root())); let text = match e.mode { // Krishiv's extensions (ADR 0023): a query that fails to @@ -77,7 +79,8 @@ impl Session { else { return Err(internal("SELECT 1 is not a query".to_owned())); }; - let plan = krishiv_sql::lower(&q, krishiv_plan::SourceId(0)).map_err(|e| e.error)?; + let plan = + krishiv_sql::lower(&q, krishiv_plan::SourceId(0), &env.parser).map_err(|e| e.error)?; let df = DataFrame::new(self.clone(), Arc::clone(plan.root())) .select([lit(text.to_owned()).alias("plan")]); df.analyzed_in(env).await?; diff --git a/crates/krishiv-session/src/session.rs b/crates/krishiv-session/src/session.rs index 91b6b143..e16ac978 100644 --- a/crates/krishiv-session/src/session.rs +++ b/crates/krishiv-session/src/session.rs @@ -335,7 +335,7 @@ impl Session { Statement::Explain(e) => return self.explain_statement(&e).await, _ => return Err(unsupported_statement("statements other than queries")), }; - let plan = krishiv_sql::lower(&q, SourceId(0)).map_err(|e| e.error)?; + let plan = krishiv_sql::lower(&q, SourceId(0), &env.parser).map_err(|e| e.error)?; let df = DataFrame::new(self.clone(), Arc::clone(plan.root())); df.analyzed_in(env).await?; Ok(df) @@ -865,13 +865,15 @@ fn job_uuid() -> String { } /// The parser's configs (`ParserOptions::from_conf` reads these). -const PARSER_KEYS: [&str; 6] = [ +const PARSER_KEYS: [&str; 8] = [ "spark.sql.ansi.enabled", "spark.sql.ansi.enforceReservedKeywords", "spark.sql.ansi.doubleQuotedIdentifiers", "spark.sql.legacy.setopsPrecedence.enabled", "spark.sql.parser.escapedStringLiterals", "spark.sql.legacy.bangEqualsNot", + "spark.sql.timestampType", + "spark.sql.session.timeZone", ]; /// `KRISHIV_UNSUPPORTED_FEATURE` for a statement `Session::sql` cannot run yet. diff --git a/crates/krishiv-sql/Cargo.toml b/crates/krishiv-sql/Cargo.toml index 7592bb8a..69ba0db8 100644 --- a/crates/krishiv-sql/Cargo.toml +++ b/crates/krishiv-sql/Cargo.toml @@ -12,6 +12,8 @@ publish = false workspace = true [dependencies] +arrow-array.workspace = true +arrow-schema.workspace = true krishiv-common = { path = "../krishiv-common" } krishiv-kernels = { path = "../krishiv-kernels" } krishiv-plan = { path = "../krishiv-plan" } diff --git a/crates/krishiv-sql/src/frontend.rs b/crates/krishiv-sql/src/frontend.rs index 901e90bc..0a02fe53 100644 --- a/crates/krishiv-sql/src/frontend.rs +++ b/crates/krishiv-sql/src/frontend.rs @@ -31,10 +31,10 @@ impl SqlFrontend for Frontend { redact_sql(query) } - /// The parser options, one bit each. + /// The parser options, one bit each, plus the session offset. fn fingerprint(&self) -> u64 { let o = self.options; - [ + let bits = [ o.enforce_reserved_keywords, o.double_quoted_identifiers, o.legacy_setops_precedence, @@ -44,6 +44,13 @@ impl SqlFrontend for Frontend { o.timestamp_ntz, ] .iter() - .fold(0, |acc, b| acc << 1 | u64::from(*b)) + .fold(0, |acc, b| acc << 1 | u64::from(*b)); + // The session offset changes how timestamp literals without a zone + // evaluate; `None` (a region zone) is one input. + let zone_bits = match o.session_offset { + Some(v) => u64::from(u32::from_ne_bytes(v.to_ne_bytes())), + None => 0x8000_0000, + }; + bits.wrapping_mul(31).wrapping_add(zone_bits) } } diff --git a/crates/krishiv-sql/src/lib.rs b/crates/krishiv-sql/src/lib.rs index 0fcb1ad4..84ebda6b 100644 --- a/crates/krishiv-sql/src/lib.rs +++ b/crates/krishiv-sql/src/lib.rs @@ -77,6 +77,11 @@ pub struct ParserOptions { /// `spark.sql.timestampType = TIMESTAMP_NTZ`: a `TIMESTAMP '...'` /// literal 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 (which needs the + /// tz database) or when unset. Typed timestamp literals without a zone + /// are evaluated in this zone at analysis time. + pub session_offset: Option, } impl ParserOptions { @@ -96,10 +101,32 @@ impl ParserOptions { legacy_interval: on("spark.sql.legacy.interval.enabled", false), timestamp_ntz: conf("spark.sql.timestampType") .is_some_and(|v| v.trim().eq_ignore_ascii_case("TIMESTAMP_NTZ")), + session_offset: conf("spark.sql.session.timeZone").and_then(fixed_offset), } } } +/// The offset of `UTC`, `GMT`, `Z` or `[+-]hh:mm`, in seconds east of UTC; +/// `None` for region ids (which need the tz database) and malformed zones. +fn fixed_offset(zone: &str) -> Option { + let zone = zone.trim(); + 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)) +} + /// Parses one query statement, optionally followed by `;`. /// /// # Errors diff --git a/crates/krishiv-sql/src/lower.rs b/crates/krishiv-sql/src/lower.rs index 5b9b8011..26ab476c 100644 --- a/crates/krishiv-sql/src/lower.rs +++ b/crates/krishiv-sql/src/lower.rs @@ -16,11 +16,17 @@ use std::collections::BTreeMap; use std::sync::Arc; +use arrow_array::StringArray; +use arrow_array::cast::AsArray; +use arrow_array::types::TimestampMicrosecondType; +use arrow_schema::{DataType as ArrowType, TimeUnit}; use krishiv_common::error::{ - FailedToParseTooComplex, KrishivError, KrishivUnsupportedFeature, MissingWindowSpecification, + ErrorClass, FailedToParseTooComplex, KrishivError, KrishivUnsupportedFeature, + MissingWindowSpecification, }; use krishiv_common::secret::OptionValue; use krishiv_common::stack::{STEP, on_big_stack}; +use krishiv_kernels::cast::{CastMode as KernelMode, CastOptions, FixedOffset, cast}; use krishiv_plan::{ Builtin, CastMode, ColumnRef, Cte, Expr as IrExpr, ExprNode, FrameBound as IrFrameBound, FrameUnits as IrFrameUnits, FunctionCall, Grouping, JoinCondition, JoinKind as IrJoin, @@ -43,25 +49,38 @@ type R = Result; /// Parses and lowers one query; spans index `source`. /// +/// Typed timestamp literals (`TIMESTAMP '...'`, `TIMESTAMP_LTZ '...`, +/// `TIMESTAMP_NTZ '...'`) are evaluated here, at analysis time, through +/// the same `CAST('...' AS TIMESTAMP)` kernels execution uses (so their +/// parsing rules match), with `options` supplying `spark.sql.timestampType` +/// (what plain `TIMESTAMP` means) and `spark.sql.session.timeZone` (for +/// instants without a zone). The result is a constant `Literal`, never a +/// per-row cast. +/// /// # 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 { - lower(&parse_query(sql, options)?, source).map_err(|e| e.redacted_in(sql)) + lower(&parse_query(sql, options)?, source, options).map_err(|e| e.redacted_in(sql)) } /// Lowers `query` into an unresolved plan whose spans index `source`. /// +/// `options` supplies `spark.sql.timestampType` and +/// `spark.sql.session.timeZone` for typed timestamp literals (see +/// [`parse_and_lower`]). +/// /// # Errors /// `KRISHIV_UNSUPPORTED_FEATURE` for constructs the IR lacks, Spark's /// literal errors (`INVALID_NUMERIC_LITERAL_RANGE`, `INVALID_TYPED_LITERAL`, /// decimal bounds, unsupported cast types) and `FAILED_TO_PARSE_TOO_COMPLEX` /// for plans deeper than `MAX_DEPTH`. -pub fn lower(query: &Query, source: SourceId) -> R { +pub fn lower(query: &Query, source: SourceId, options: &ParserOptions) -> R { let mut l = Lowerer { source, depth: 0, root: query.span, windows: Vec::new(), + options: *options, }; let plan = l.query(query)?; Plan::try_new(plan).map_err(|e| err(e, query.span)) @@ -105,6 +124,9 @@ struct Lowerer { /// last; `None` stands for a subquery expression's boundary (Spark's /// `WindowsSubstitution` does not enter subquery plans). windows: Vec>>, + /// The session configs timestamp literals read (`spark.sql.timestampType` + /// and `spark.sql.session.timeZone`). + options: ParserOptions, } /// A `WINDOW` clause: each name's specification, references to other @@ -737,7 +759,7 @@ impl Lowerer { fn expr_inner(&mut self, e: &Expr) -> R { let sp = e.span; Ok(match &e.kind { - ExprKind::Literal(v) => self.ex(ExprNode::Literal(literal(v, sp)?), sp), + ExprKind::Literal(v) => self.ex(ExprNode::Literal(literal(v, sp, &self.options)?), sp), ExprKind::Keyword(k) => { self.ex(ExprNode::Literal(IrLiteral::String(k.value.clone())), sp) } @@ -1134,7 +1156,7 @@ fn is_path(s: &str) -> bool { s.contains('/') || s.contains(':') } -fn literal(v: &Literal, sp: Span) -> R { +fn literal(v: &Literal, sp: Span, options: &ParserOptions) -> R { Ok(match v { Literal::Null => IrLiteral::Null(None), Literal::Boolean(b) => IrLiteral::Boolean(*b), @@ -1149,6 +1171,9 @@ fn literal(v: &Literal, sp: Span) -> R { TypedKind::Binary => IrLiteral::Binary( literal::hex(value).ok_or_else(|| err(kind.invalid(value), sp))?, ), + TypedKind::Timestamp | TypedKind::TimestampLtz | TypedKind::TimestampNtz => { + timestamp_literal(kind, value, options, sp)? + } _ => { let t = type_name.value.to_ascii_uppercase(); return Err(unsupported(&format!("{t} literals"), sp)); @@ -1159,6 +1184,177 @@ fn literal(v: &Literal, sp: Span) -> R { }) } +/// A typed timestamp literal as Spark's `AstBuilder` builds it: the same +/// `CAST('...' AS TIMESTAMP)` kernels execution uses, evaluated once here +/// (a constant, never per row). +/// +/// Plain `TIMESTAMP` means `TIMESTAMP_NTZ` when +/// `spark.sql.timestampType = TIMESTAMP_NTZ` and the value names no zone, +/// else `TIMESTAMP_LTZ`. Values needing the query clock (`now`, `today`, +/// a bare time of day) or the tz 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, with the span +/// of the literal. +fn timestamp_literal( + kind: TypedKind, + value: &str, + options: &ParserOptions, + sp: Span, +) -> R { + use krishiv_kernels::cast::TimestampText; + use krishiv_kernels::cast::timestamp_text; + // Clock-dependent spellings evaluate with the query clock, which this + // layer has not got. + if literal::is_special(value) { + return Err(unsupported( + "a timestamp literal that needs the query clock", + sp, + )); + } + let shape = timestamp_text(value); + if shape == TimestampText::Malformed { + return Err(err(kind.invalid(value), sp)); + } + // 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 == TypedKind::TimestampNtz + || (kind == TypedKind::Timestamp && options.timestamp_ntz); + if without_zone { + return Err(err(kind.invalid(value), sp)); + } + return Err(unsupported( + "a timestamp literal that needs the query clock", + sp, + )); + } + match kind { + TypedKind::TimestampNtz => { + let micros = + cast_timestamp_ntz(value).map_err(|e| map_timestamp_error(e, kind, value, sp))?; + Ok(IrLiteral::TimestampNtz(micros)) + } + TypedKind::TimestampLtz => { + let micros = cast_timestamp_ltz(value, options.session_offset) + .map_err(|e| map_timestamp_error(e, kind, value, sp))?; + Ok(IrLiteral::Timestamp(micros)) + } + TypedKind::Timestamp if options.timestamp_ntz => { + // Under `TIMESTAMP_NTZ`, a value naming a zone is still an + // instant; without one it is wall-clock time. + if has_explicit_zone(value) { + let micros = cast_timestamp_ltz(value, options.session_offset) + .map_err(|e| map_timestamp_error(e, kind, value, sp))?; + Ok(IrLiteral::Timestamp(micros)) + } else { + let micros = cast_timestamp_ntz(value) + .map_err(|e| map_timestamp_error(e, kind, value, sp))?; + Ok(IrLiteral::TimestampNtz(micros)) + } + } + _ => { + let micros = cast_timestamp_ltz(value, options.session_offset) + .map_err(|e| map_timestamp_error(e, kind, value, sp))?; + Ok(IrLiteral::Timestamp(micros)) + } + } +} + +/// Whether `value` names an explicit zone: an instant whose `CAST` result +/// does not move with the session zone. Probed with the cast kernels +/// themselves (no second parser): the same value cast in two session zones +/// agrees exactly then. +fn has_explicit_zone(value: &str) -> bool { + let (Ok(a), Ok(b)) = ( + cast_one(value, <z_arrow(), &FixedOffset(0)), + cast_one(value, <z_arrow(), &FixedOffset(3600)), + ) else { + // Malformed or needing the tz database or clock: the caller maps + // the error; the zone question is moot. + return false; + }; + a == b +} + +/// The Arrow carrier of `TIMESTAMP`. +fn ltz_arrow() -> ArrowType { + ArrowType::Timestamp(TimeUnit::Microsecond, Some("UTC".into())) +} + +/// The Arrow carrier of `TIMESTAMP_NTZ`. +fn ntz_arrow() -> ArrowType { + ArrowType::Timestamp(TimeUnit::Microsecond, None) +} + +/// `value` cast as Spark casts `CAST(value AS TIMESTAMP_NTZ)`. +fn cast_timestamp_ntz(value: &str) -> Result { + let out = cast_one(value, &ntz_arrow(), &FixedOffset(0))?; + Ok(out) +} + +/// `value` cast as Spark casts `CAST(value AS TIMESTAMP)` in `session`. +/// `None` (a region session zone, or unset) serves values with an explicit +/// zone; values without one need the zone and are unsupported there. +fn cast_timestamp_ltz(value: &str, session: Option) -> Result { + // Session-independent values (an explicit offset) evaluate under any + // zone; only session-dependent ones read `session`. + let probe = cast_one(value, <z_arrow(), &FixedOffset(0)); + let probe2 = cast_one(value, <z_arrow(), &FixedOffset(3600)); + match (probe, probe2) { + (Ok(a), Ok(b)) if a == b => Ok(a), + (Ok(_), Ok(_)) => match session { + Some(off) => cast_one(value, <z_arrow(), &FixedOffset(off)), + None => Err(KrishivUnsupportedFeature { + feature: "a timestamp literal in a session time zone other than a fixed offset" + .to_owned(), + } + .into()), + }, + (Ok(a), Err(_)) => Ok(a), + (Err(e), _) => Err(e), + } +} + +/// One string cast through the kernels, as a microsecond instant or NTZ +/// wall-clock value. +fn cast_one(value: &str, to: &ArrowType, zone: &FixedOffset) -> Result { + 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(KrishivUnsupportedFeature { + feature: "a timestamp literal".to_owned(), + } + .into()); + } + Ok(out.as_primitive::().value(0)) +} + +/// A cast failure as the literal's error: malformed text is +/// `INVALID_TYPED_LITERAL` at the literal; anything needing the tz database +/// or clock stays `KRISHIV_UNSUPPORTED_FEATURE`. +fn map_timestamp_error(e: KrishivError, kind: TypedKind, value: &str, sp: Span) -> ParseError { + if e.error_class() == ErrorClass::KrishivUnsupportedFeature { + return err(e, sp); + } + err(kind.invalid(value), sp) +} + +/// The literal lowering, for tests of timestamp literals without parsing a +/// whole query. +#[cfg(test)] +pub(crate) fn literal_for_tests(v: &Literal, sp: Span, options: &ParserOptions) -> R { + literal(v, sp, options) +} + /// A numeric literal as Spark's `AstBuilder` types it. fn number(text: &str, kind: NumKind, sp: Span) -> R { Ok(match literal::number(text, kind).map_err(|e| err(e, sp))? { diff --git a/crates/krishiv-sql/src/tests.rs b/crates/krishiv-sql/src/tests.rs index 4bc49a1f..67dd848f 100644 --- a/crates/krishiv-sql/src/tests.rs +++ b/crates/krishiv-sql/src/tests.rs @@ -953,3 +953,136 @@ fn multipart_identifiers_parse_like_spark() { let e = parse_multipart_identifier("", &d).unwrap_err(); assert_eq!(e.error.error_class(), ErrorClass::ParseEmptyStatement); } + +/// Typed datetime literals lower through the `CAST` kernels, once, with the +/// session zone and `spark.sql.timestampType`. +#[test] +fn typed_timestamp_literals_lower_like_cast() { + use crate::ast::{ExprKind, SetExprKind}; + use krishiv_plan::{Literal as IrLiteral, SourceId}; + + let utc = ParserOptions { + session_offset: Some(0), + ..ParserOptions::default() + }; + let plus5 = ParserOptions { + session_offset: Some(5 * 3600 + 30 * 60), + ..ParserOptions::default() + }; + let ntz = ParserOptions { + timestamp_ntz: true, + session_offset: Some(0), + ..ParserOptions::default() + }; + let region = ParserOptions { + session_offset: None, + ..ParserOptions::default() + }; + let lit = |sql: &str, options: &ParserOptions| { + let q = parser::parse_query_unchecked(sql, *options).unwrap(); + let SetExprKind::Select(s) = q.body.kind else { + panic!("{sql} is not a select"); + }; + let ExprKind::Literal(v) = s.projection[0].expr.kind.clone() else { + panic!("{sql} is not a literal"); + }; + crate::lower::literal_for_tests(&v, s.projection[0].expr.span, options) + }; + // `2024-01-01 10:00:00` in UTC is 10:00 UTC. + assert_eq!( + lit("SELECT TIMESTAMP '2024-01-01 10:00:00'", &utc).unwrap(), + IrLiteral::Timestamp(1_704_103_200_000_000) + ); + // The same wall-clock time in +05:30 is 04:30 UTC. + assert_eq!( + lit("SELECT TIMESTAMP '2024-01-01 10:00:00'", &plus5).unwrap(), + IrLiteral::Timestamp(1_704_083_400_000_000) + ); + // Explicit offsets ignore the session zone. + assert_eq!( + lit("SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'", &utc).unwrap(), + IrLiteral::Timestamp(1_704_083_400_000_000) + ); + assert_eq!( + lit("SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'", &plus5).unwrap(), + IrLiteral::Timestamp(1_704_083_400_000_000) + ); + // `TIMESTAMP_LTZ` is always an instant. + assert_eq!( + lit("SELECT TIMESTAMP_LTZ '2024-01-01 10:00:00'", &utc).unwrap(), + IrLiteral::Timestamp(1_704_103_200_000_000) + ); + // `TIMESTAMP_NTZ` is wall-clock time, the zone ignored. + assert_eq!( + lit("SELECT TIMESTAMP_NTZ '2024-01-01 10:00:00'", &utc).unwrap(), + IrLiteral::TimestampNtz(1_704_103_200_000_000) + ); + assert_eq!( + lit("SELECT TIMESTAMP_NTZ '2024-01-01 10:00:00+05:30'", &utc).unwrap(), + IrLiteral::TimestampNtz(1_704_103_200_000_000) + ); + // Plain `TIMESTAMP` under `TIMESTAMP_NTZ` is wall-clock without a zone, + // an instant with one. + assert_eq!( + lit("SELECT TIMESTAMP '2024-01-01 10:00:00'", &ntz).unwrap(), + IrLiteral::TimestampNtz(1_704_103_200_000_000) + ); + assert_eq!( + lit("SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'", &ntz).unwrap(), + IrLiteral::Timestamp(1_704_083_400_000_000) + ); + // Invalid text is `INVALID_TYPED_LITERAL` at the literal. + for (sql, options) in [ + ("SELECT TIMESTAMP '2024-13-01 10:00:00'", &utc), + ("SELECT TIMESTAMP_NTZ '10:00'", &utc), + ("SELECT TIMESTAMP '10:00'", &ntz), + ("SELECT TIMESTAMP_LTZ 'not-a-date'", &utc), + ] { + let e = lit(sql, options).unwrap_err(); + assert_eq!( + e.error.error_class(), + ErrorClass::InvalidTypedLiteral, + "{sql}" + ); + assert_eq!(e.span.range(), 7..sql.len(), "{sql}"); + } + // A region session zone serves explicit offsets but not wall-clock time. + assert!(lit("SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'", ®ion).is_ok()); + let e = lit("SELECT TIMESTAMP '2024-01-01 10:00:00'", ®ion).unwrap_err(); + assert_eq!(e.error.error_class(), ErrorClass::KrishivUnsupportedFeature); + assert!(e.error.to_string().contains("session time zone"), "{e}"); + // Clock-dependent spellings need the query clock. + for sql in [ + "SELECT TIMESTAMP 'now'", + "SELECT TIMESTAMP_LTZ '10:00'", + "SELECT TIMESTAMP '10:00'", + ] { + let e = lit(sql, &utc).unwrap_err(); + assert_eq!( + e.error.error_class(), + ErrorClass::KrishivUnsupportedFeature, + "{sql}" + ); + assert!(e.error.to_string().contains("query clock"), "{sql}: {e}"); + } + // `parse_and_lower` evaluates once (a constant): the plan holds a + // literal, not a cast. + let plan = crate::parse_and_lower("SELECT TIMESTAMP '2024-01-01 10:00:00'", &utc, SourceId(0)) + .unwrap(); + assert!(plan.root().to_string().contains("1704103200000000")); + // The session configs flow through `from_conf`. + let opts = ParserOptions::from_conf(|k| { + [ + ("spark.sql.timestampType", "TIMESTAMP_NTZ"), + ("spark.sql.session.timeZone", "+05:30"), + ] + .iter() + .find(|(key, _)| *key == k) + .map(|(_, v)| *v) + }); + assert!(opts.timestamp_ntz); + assert_eq!(opts.session_offset, Some(19_800)); + let default = ParserOptions::from_conf(|_| None); + assert!(!default.timestamp_ntz); + assert_eq!(default.session_offset, None); +} diff --git a/crates/krishiv-sql/src/validate/literal.rs b/crates/krishiv-sql/src/validate/literal.rs index b7ca2e4a..2e501a8e 100644 --- a/crates/krishiv-sql/src/validate/literal.rs +++ b/crates/krishiv-sql/src/validate/literal.rs @@ -228,7 +228,7 @@ fn is_no_break_space(c: char) -> bool { /// The special values of `DATE` and `TIMESTAMP` literals (`now`, /// `epoch`, ...), which depend on the session's clock and zone. -fn is_special(value: &str) -> bool { +pub(crate) fn is_special(value: &str) -> bool { let v = value.trim().to_ascii_lowercase(); ["epoch", "now", "today", "yesterday", "tomorrow"].contains(&v.as_str()) } diff --git a/crates/krishiv-sql/tests/analyzer.rs b/crates/krishiv-sql/tests/analyzer.rs index 6f35b401..e0d61ada 100644 --- a/crates/krishiv-sql/tests/analyzer.rs +++ b/crates/krishiv-sql/tests/analyzer.rs @@ -526,3 +526,72 @@ fn window_goldens_resolve_to_a_fixed_point() { assert_eq!(resolved, 66); assert!(failures.is_empty(), "{}", failures.join("\n")); } + +/// Typed datetime literals resolve to Spark's types and names: plain +/// `TIMESTAMP` follows `spark.sql.timestampType` (and a zone in the value), +/// and instants without a zone read the session zone. 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, offset: Option| { + let options = ParserOptions { + timestamp_ntz, + session_offset: offset, + ..ParserOptions::default() + }; + let plan = parse_and_lower(sql, &options, SourceId(0)).map_err(|e| AnalysisError { + error: e.error, + origin: krishiv_plan::Origin::UNKNOWN, + })?; + block_on(DefaultAnalyzer.analyze(&plan, &context(catalog(&g), ResolutionConf::default()))) + }; + 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). + 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(); + assert_ne!( + utc_plan.plan.root().to_string(), + plus_plan.plan.root().to_string() + ); + // `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"); + // 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}"); + } +} 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..26f93ccd 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 + => [KRISHIV_UNSUPPORTED_FEATURE] The feature a timestamp literal in a session time zone other than a fixed offset is not supported by Krishiv yet. SQLSTATE: 0A000 @ 7..38 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 From fb305e7bee38ea275a84fe18a184dcce17c59fe3 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Fri, 23 Oct 2026 18:49:24 +0200 Subject: [PATCH 2/4] Resolve typed datetime literals in the analyzer with the session zone Parser produces an unresolved TypedLiteral node only (type keyword plus raw string); no evaluation, no time zone and no ParserOptions or fingerprint changes there. The analyzer lowers DATE, TIMESTAMP, TIMESTAMP_NTZ and TIMESTAMP_LTZ to a constant Literal with the string-to-date/timestamp cast kernels and the session-resolved zone (spark.sql.session.timeZone, default UTC when unset, the same default the cast path uses) and timestamp type (spark.sql.timestampType decides plain TIMESTAMP, with an explicit zone in the value staying an instant). Zone detection uses the kernel parse result via timestamp_has_zone, not double casting. Clock-dependent spellings and region zones stay KRISHIV_UNSUPPORTED_FEATURE; malformed text is INVALID_TYPED_LITERAL with the literal position. Output names use the cast-to-string kernels in the session zone; the hand-written UTC formatter is removed. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- Cargo.lock | 2 - crates/krishiv-kernels/src/cast.rs | 2 +- crates/krishiv-kernels/src/cast/timestamp.rs | 11 + crates/krishiv-plan/src/analyzer/exprs.rs | 381 +++++++++++++++--- crates/krishiv-plan/src/analyzer/hints.rs | 4 +- crates/krishiv-plan/src/analyzer/mod.rs | 54 ++- crates/krishiv-plan/src/analyzer/ops.rs | 35 +- crates/krishiv-plan/src/analyzer/setops.rs | 2 +- crates/krishiv-plan/src/analyzer/subquery.rs | 4 +- crates/krishiv-plan/src/analyzer/windows.rs | 46 ++- crates/krishiv-plan/src/display.rs | 9 + crates/krishiv-plan/src/encode.rs | 10 + crates/krishiv-plan/src/expr.rs | 26 ++ crates/krishiv-plan/src/lib.rs | 2 +- crates/krishiv-plan/src/tests/analyzer.rs | 130 ++++++ crates/krishiv-plan/src/tests/inventory.rs | 1 + crates/krishiv-plan/src/tests/props.rs | 1 + crates/krishiv-plan/src/walk.rs | 2 + crates/krishiv-session/src/explain.rs | 7 +- crates/krishiv-session/src/session.rs | 6 +- crates/krishiv-session/tests/session.rs | 54 +++ crates/krishiv-sql/Cargo.toml | 2 - crates/krishiv-sql/src/frontend.rs | 13 +- crates/krishiv-sql/src/lib.rs | 27 -- crates/krishiv-sql/src/lower.rs | 244 ++--------- crates/krishiv-sql/src/tests.rs | 179 +++----- crates/krishiv-sql/src/validate/literal.rs | 2 +- crates/krishiv-sql/tests/analyzer.rs | 85 +++- ...cts_lower_or_are_named_as_unsupported.snap | 2 +- ...iterals_are_typed_as_spark_types_them.snap | 2 +- 30 files changed, 839 insertions(+), 506 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9e2ba81a..7a66e93b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1740,8 +1740,6 @@ version = "0.1.0-alpha" name = "krishiv-sql" version = "0.1.0-alpha" dependencies = [ - "arrow-array", - "arrow-schema", "codspeed-criterion-compat", "insta", "krishiv-common", 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/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 595f4a7e..59e3dd97 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. @@ -171,13 +172,14 @@ fn bad_cast( arg: &Bound, to: &DataType, mode: CastMode, + zone: Option, ) -> 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 { @@ -258,6 +260,188 @@ pub(super) fn literal_type(v: &Literal) -> Option { }) } +/// 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 { + 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); + if shape == TimestampText::Malformed { + // `DATE` shares the timestamp grammar's shape check: a malformed + // date is `INVALID_TYPED_LITERAL` too. + 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::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::().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::().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, <z_arrow(), &FixedOffset(0)).map_err(map_error)?; + Ok(Literal::Timestamp(micros)) + } else { + match conf.session_zone { + Some(off) => { + let micros = + cast_one(value, <z_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, <z_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, <z_arrow(), &FixedOffset(0)).map_err(map_error)?; + Ok(Literal::Timestamp(micros)) + } else { + match conf.session_zone { + Some(off) => { + let micros = + cast_one(value, <z_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 @@ -481,6 +665,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 { @@ -497,7 +695,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, )); @@ -565,7 +766,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| { @@ -683,7 +891,8 @@ impl Resolver<'_> { .map(|k| fold::constant(&k.expr, self.ctx.conf.ansi)) .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 = kids.iter().map(|k| k.ty.clone()).collect(); let ansi = self.ctx.conf.ansi; let loss = self.ctx.conf.decimal_precision_loss; @@ -844,7 +1053,8 @@ impl Resolver<'_> { cx: &Cx<'_>, ) -> Result<(Vec, Arc), 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| v.join(", "); if kids.len() != rel.out.len() { return Err(AnalysisError::new( @@ -853,7 +1063,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(), @@ -886,7 +1096,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) @@ -977,7 +1190,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, @@ -1003,7 +1217,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, ), @@ -1016,7 +1232,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()), @@ -1428,8 +1644,10 @@ fn call_checks( /// 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) -> String { let mut done: HashMap = HashMap::new(); let mut stack = vec![(e, false)]; while let Some((x, expanded)) = stack.pop() { @@ -1447,7 +1665,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). @@ -1484,13 +1702,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) -> 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" @@ -1519,7 +1746,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, None, *distinct, k), ExprNode::Resolved(ResolvedExpr::Function(f)) => { let op = match &f.id { @@ -1540,7 +1767,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) -> String { use crate::{FrameBound, FrameUnits, WindowSpecRef}; let function = match &w.function.node { ExprNode::Resolved(ResolvedExpr::Function(f)) @@ -1587,7 +1814,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"), } } @@ -1674,7 +1901,7 @@ fn call(name: &str, op: Option, distinct: bool, k: &[&str]) -> String { } } -fn pretty_literal(v: &Literal) -> String { +fn pretty_literal(v: &Literal, zone: Option) -> String { let text = v.to_string(); match v { // A URL's credentials never reach a name (ADR 0038). @@ -1687,58 +1914,82 @@ fn pretty_literal(v: &Literal) -> String { Literal::Float(x) => format!("{x:?}"), Literal::Double(x) => format!("{x:?}"), Literal::Decimal { .. } => text.trim_end_matches("BD").to_owned(), - // Spark's `toPrettySQL` of a timestamp literal, in the session zone. - // Lowering evaluates session-independent values (and session ones in - // a fixed-offset zone) with the kernels and formats here in UTC; - // values without a zone read the same either way, so names match - // Spark's for them. - Literal::Timestamp(us) => format!("TIMESTAMP '{}'", format_timestamp(*us)), - Literal::TimestampNtz(us) => format!("TIMESTAMP_NTZ '{}'", format_timestamp(*us)), + // Spark's `toPrettySQL` of a timestamp literal, in the session + // zone: the same cast-to-string kernels `CAST(ts AS STRING)` uses. + Literal::Timestamp(us) => format!("TIMESTAMP '{}'", cast_to_string_timestamp(*us, zone)), + Literal::TimestampNtz(us) => { + format!("TIMESTAMP_NTZ '{}'", cast_to_string_ntz(*us)) + } + Literal::Date(days) => format!("DATE '{}'", cast_to_string_date(*days)), _ => text, } } -/// Microseconds since the epoch as `yyyy-MM-dd HH:mm:ss[.fraction]`, the -/// proleptic Gregorian date (as Spark prints a timestamp literal). -fn format_timestamp(micros: i64) -> String { - const MICROS_PER_DAY: i64 = 86_400_000_000; - const MICROS_PER_SECOND: i64 = 1_000_000; - let days = micros.div_euclid(MICROS_PER_DAY); - let rest = micros.rem_euclid(MICROS_PER_DAY); - let (y, m, d) = civil_from_days(days); - let sign = if y < 0 { "-" } else { "" }; - let mut out = format!("{sign}{:04}-{:02}-{:02}", y.unsigned_abs(), m, d); - let secs = rest / MICROS_PER_SECOND; - let frac = rest % MICROS_PER_SECOND; - { - use std::fmt::Write as _; - let _ = write!( - &mut out, - " {:02}:{:02}:{:02}", - secs / 3600, - secs / 60 % 60, - secs % 60 - ); - if frac != 0 { - let digits = format!("{frac:06}"); - let _ = write!(&mut out, ".{}", digits.trim_end_matches('0')); - } - } - out +/// `micros` (a UTC instant) as `CAST(micros AS STRING)` renders it: in the +/// session zone. The cast never fails (out-of-range locals fall back to +/// the instant itself, as the kernels do). +fn cast_to_string_timestamp(micros: i64, zone: Option) -> String { + use arrow_array::Array as _; + use arrow_array::TimestampMicrosecondArray; + use arrow_array::cast::AsArray as _; + use krishiv_kernels::cast::{CastMode as KernelMode, CastOptions, FixedOffset, cast}; + // A region session zone needs the time-zone database, which the engine + // has not got: fall back to UTC for the name (the query itself fails + // with `KRISHIV_UNSUPPORTED_FEATURE` where the zone matters). + let fixed = FixedOffset(zone.unwrap_or(0)); + let input = TimestampMicrosecondArray::from(vec![micros]) + .with_data_type(krishiv_types::DataType::Timestamp.to_arrow()); + let opts = CastOptions { + mode: KernelMode::Ansi, + time_zone: &fixed, + }; + cast(&input, &arrow_schema::DataType::Utf8, &opts) + .ok() + .and_then(|out| { + let s = out.as_string::(); + (s.len() == 1 && !s.is_null(0)).then(|| s.value(0).to_owned()) + }) + .unwrap_or_else(|| micros.to_string()) +} + +/// `micros` (NTZ wall-clock time) as `CAST(micros AS STRING)` renders it. +fn cast_to_string_ntz(micros: i64) -> String { + use arrow_array::Array as _; + use arrow_array::TimestampMicrosecondArray; + use arrow_array::cast::AsArray as _; + use krishiv_kernels::cast::{CastMode as KernelMode, CastOptions, FixedOffset, cast}; + let input = TimestampMicrosecondArray::from(vec![micros]); + let opts = CastOptions { + mode: KernelMode::Ansi, + time_zone: &FixedOffset(0), + }; + cast(&input, &arrow_schema::DataType::Utf8, &opts) + .ok() + .and_then(|out| { + let s = out.as_string::(); + (s.len() == 1 && !s.is_null(0)).then(|| s.value(0).to_owned()) + }) + .unwrap_or_else(|| micros.to_string()) } -/// `(year, month, day)` of a day number (H. Hinnant's `civil_from_days`). -fn civil_from_days(days: i64) -> (i64, i64, i64) { - let z = days + 719_468; - let era = z.div_euclid(146_097); - let doe = z.rem_euclid(146_097); - let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; - let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); - let mp = (5 * doy + 2) / 153; - let day = doy - (153 * mp + 2) / 5 + 1; - let month = if mp < 10 { mp + 3 } else { mp - 9 }; - let year = yoe + era * 400 + i64::from(month <= 2); - (year, month, day) +/// `days` as `CAST(days AS STRING)` renders it. +fn cast_to_string_date(days: i32) -> String { + use arrow_array::Array as _; + use arrow_array::Date32Array; + use arrow_array::cast::AsArray as _; + use krishiv_kernels::cast::{CastMode as KernelMode, CastOptions, FixedOffset, cast}; + let input = Date32Array::from(vec![days]); + let opts = CastOptions { + mode: KernelMode::Ansi, + time_zone: &FixedOffset(0), + }; + cast(&input, &arrow_schema::DataType::Utf8, &opts) + .ok() + .and_then(|out| { + let s = out.as_string::(); + (s.len() == 1 && !s.is_null(0)).then(|| s.value(0).to_owned()) + }) + .unwrap_or_else(|| days.to_string()) } /// A semantic key: equal for expressions that compute the same value, 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 52bc4fe1..fd960adc 100644 --- a/crates/krishiv-plan/src/analyzer/mod.rs +++ b/crates/krishiv-plan/src/analyzer/mod.rs @@ -123,6 +123,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, } impl Default for ResolutionConf { @@ -137,13 +146,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", @@ -152,6 +163,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 @@ -169,7 +182,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 { @@ -181,10 +194,38 @@ 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) => fixed_offset(s), + }, } } } +/// The offset of `UTC`, `GMT`, `Z` or `[+-]hh:mm`, in seconds east of UTC; +/// `None` for region ids (which need the time-zone database) and malformed +/// zones. +fn fixed_offset(zone: &str) -> Option { + let zone = zone.trim(); + 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)) +} + /// Everything resolution may read. #[derive(Clone)] pub struct AnalysisContext { @@ -257,12 +298,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 3e4b3a60..bce09ad4 100644 --- a/crates/krishiv-plan/src/analyzer/ops.rs +++ b/crates/krishiv-plan/src/analyzer/ops.rs @@ -306,13 +306,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; @@ -462,7 +463,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, @@ -716,7 +717,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), @@ -908,7 +909,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(), @@ -1059,7 +1060,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}\""), @@ -1092,7 +1093,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), @@ -1136,7 +1137,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}\""), @@ -1199,7 +1200,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, @@ -1433,7 +1437,7 @@ impl Resolver<'_> { if name == "limit" { "Limit" } else { "Offset" }, ); let b = self.bind(e, &cx)?; - let shown = || format!("\"{}\"", pretty(&b.shown())); + let shown = || format!("\"{}\"", pretty(&b.shown(), self.ctx.conf.session_zone)); if not_constant(&b.expr) { return Err(AnalysisError::new( InvalidLimitLikeExpressionIsUnfoldable { @@ -1643,7 +1647,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, }, @@ -1658,7 +1662,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(), @@ -1749,7 +1753,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, @@ -1777,7 +1784,7 @@ fn aggregate_sql(e: &Arc, 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/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, 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 = 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 2f7bfeb8..5e0af271 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>) { 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 10b84ff5..f915c621 100644 --- a/crates/krishiv-plan/src/lib.rs +++ b/crates/krishiv-plan/src/lib.rs @@ -120,7 +120,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 1e280ceb..75706c0d 100644 --- a/crates/krishiv-plan/src/tests/analyzer.rs +++ b/crates/krishiv-plan/src/tests/analyzer.rs @@ -1347,6 +1347,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(); @@ -1910,3 +1927,116 @@ fn try_arithmetic_casts_its_arguments_in_try_mode() { // A TRY cast of a string may be NULL; `try_*` results are nullable anyway. 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, LogicalPlan, Plan, 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)) + }; + 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; names render in it. + 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_ne!( + utc_plan.plan.root().to_string(), + plus_plan.plan.root().to_string() + ); + 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"), + ] { + 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); +} 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, 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/src/explain.rs b/crates/krishiv-session/src/explain.rs index 52c4b681..3f741d91 100644 --- a/crates/krishiv-session/src/explain.rs +++ b/crates/krishiv-session/src/explain.rs @@ -53,9 +53,7 @@ impl Session { } .into()); }; - let env = self.query_env(); - let plan = - krishiv_sql::lower(q, krishiv_plan::SourceId(0), &env.parser).map_err(|e| e.error)?; + let plan = krishiv_sql::lower(q, krishiv_plan::SourceId(0)).map_err(|e| e.error)?; let explained = DataFrame::new(self.clone(), Arc::clone(plan.root())); let text = match e.mode { // Krishiv's extensions (ADR 0023): a query that fails to @@ -79,8 +77,7 @@ impl Session { else { return Err(internal("SELECT 1 is not a query".to_owned())); }; - let plan = - krishiv_sql::lower(&q, krishiv_plan::SourceId(0), &env.parser).map_err(|e| e.error)?; + let plan = krishiv_sql::lower(&q, krishiv_plan::SourceId(0)).map_err(|e| e.error)?; let df = DataFrame::new(self.clone(), Arc::clone(plan.root())) .select([lit(text.to_owned()).alias("plan")]); df.analyzed_in(env).await?; diff --git a/crates/krishiv-session/src/session.rs b/crates/krishiv-session/src/session.rs index e16ac978..91b6b143 100644 --- a/crates/krishiv-session/src/session.rs +++ b/crates/krishiv-session/src/session.rs @@ -335,7 +335,7 @@ impl Session { Statement::Explain(e) => return self.explain_statement(&e).await, _ => return Err(unsupported_statement("statements other than queries")), }; - let plan = krishiv_sql::lower(&q, SourceId(0), &env.parser).map_err(|e| e.error)?; + let plan = krishiv_sql::lower(&q, SourceId(0)).map_err(|e| e.error)?; let df = DataFrame::new(self.clone(), Arc::clone(plan.root())); df.analyzed_in(env).await?; Ok(df) @@ -865,15 +865,13 @@ fn job_uuid() -> String { } /// The parser's configs (`ParserOptions::from_conf` reads these). -const PARSER_KEYS: [&str; 8] = [ +const PARSER_KEYS: [&str; 6] = [ "spark.sql.ansi.enabled", "spark.sql.ansi.enforceReservedKeywords", "spark.sql.ansi.doubleQuotedIdentifiers", "spark.sql.legacy.setopsPrecedence.enabled", "spark.sql.parser.escapedStringLiterals", "spark.sql.legacy.bangEqualsNot", - "spark.sql.timestampType", - "spark.sql.session.timeZone", ]; /// `KRISHIV_UNSUPPORTED_FEATURE` for a statement `Session::sql` cannot run yet. diff --git a/crates/krishiv-session/tests/session.rs b/crates/krishiv-session/tests/session.rs index 4de5e344..fc207325 100644 --- a/crates/krishiv-session/tests/session.rs +++ b/crates/krishiv-session/tests/session.rs @@ -1127,3 +1127,57 @@ fn decimal_quotients_round_before_they_are_summed() { ["11694972e-6"] ); } + +/// 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::() + .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::() + .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'"); +} diff --git a/crates/krishiv-sql/Cargo.toml b/crates/krishiv-sql/Cargo.toml index 69ba0db8..7592bb8a 100644 --- a/crates/krishiv-sql/Cargo.toml +++ b/crates/krishiv-sql/Cargo.toml @@ -12,8 +12,6 @@ publish = false workspace = true [dependencies] -arrow-array.workspace = true -arrow-schema.workspace = true krishiv-common = { path = "../krishiv-common" } krishiv-kernels = { path = "../krishiv-kernels" } krishiv-plan = { path = "../krishiv-plan" } diff --git a/crates/krishiv-sql/src/frontend.rs b/crates/krishiv-sql/src/frontend.rs index 0a02fe53..901e90bc 100644 --- a/crates/krishiv-sql/src/frontend.rs +++ b/crates/krishiv-sql/src/frontend.rs @@ -31,10 +31,10 @@ impl SqlFrontend for Frontend { redact_sql(query) } - /// The parser options, one bit each, plus the session offset. + /// The parser options, one bit each. fn fingerprint(&self) -> u64 { let o = self.options; - let bits = [ + [ o.enforce_reserved_keywords, o.double_quoted_identifiers, o.legacy_setops_precedence, @@ -44,13 +44,6 @@ impl SqlFrontend for Frontend { o.timestamp_ntz, ] .iter() - .fold(0, |acc, b| acc << 1 | u64::from(*b)); - // The session offset changes how timestamp literals without a zone - // evaluate; `None` (a region zone) is one input. - let zone_bits = match o.session_offset { - Some(v) => u64::from(u32::from_ne_bytes(v.to_ne_bytes())), - None => 0x8000_0000, - }; - bits.wrapping_mul(31).wrapping_add(zone_bits) + .fold(0, |acc, b| acc << 1 | u64::from(*b)) } } diff --git a/crates/krishiv-sql/src/lib.rs b/crates/krishiv-sql/src/lib.rs index 84ebda6b..0fcb1ad4 100644 --- a/crates/krishiv-sql/src/lib.rs +++ b/crates/krishiv-sql/src/lib.rs @@ -77,11 +77,6 @@ pub struct ParserOptions { /// `spark.sql.timestampType = TIMESTAMP_NTZ`: a `TIMESTAMP '...'` /// literal 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 (which needs the - /// tz database) or when unset. Typed timestamp literals without a zone - /// are evaluated in this zone at analysis time. - pub session_offset: Option, } impl ParserOptions { @@ -101,32 +96,10 @@ impl ParserOptions { legacy_interval: on("spark.sql.legacy.interval.enabled", false), timestamp_ntz: conf("spark.sql.timestampType") .is_some_and(|v| v.trim().eq_ignore_ascii_case("TIMESTAMP_NTZ")), - session_offset: conf("spark.sql.session.timeZone").and_then(fixed_offset), } } } -/// The offset of `UTC`, `GMT`, `Z` or `[+-]hh:mm`, in seconds east of UTC; -/// `None` for region ids (which need the tz database) and malformed zones. -fn fixed_offset(zone: &str) -> Option { - let zone = zone.trim(); - 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)) -} - /// Parses one query statement, optionally followed by `;`. /// /// # Errors diff --git a/crates/krishiv-sql/src/lower.rs b/crates/krishiv-sql/src/lower.rs index 26ab476c..47034cbd 100644 --- a/crates/krishiv-sql/src/lower.rs +++ b/crates/krishiv-sql/src/lower.rs @@ -16,23 +16,17 @@ use std::collections::BTreeMap; use std::sync::Arc; -use arrow_array::StringArray; -use arrow_array::cast::AsArray; -use arrow_array::types::TimestampMicrosecondType; -use arrow_schema::{DataType as ArrowType, TimeUnit}; use krishiv_common::error::{ - ErrorClass, FailedToParseTooComplex, KrishivError, KrishivUnsupportedFeature, - MissingWindowSpecification, + FailedToParseTooComplex, KrishivError, KrishivUnsupportedFeature, MissingWindowSpecification, }; use krishiv_common::secret::OptionValue; use krishiv_common::stack::{STEP, on_big_stack}; -use krishiv_kernels::cast::{CastMode as KernelMode, CastOptions, FixedOffset, cast}; 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; @@ -49,38 +43,30 @@ type R = Result; /// Parses and lowers one query; spans index `source`. /// -/// Typed timestamp literals (`TIMESTAMP '...'`, `TIMESTAMP_LTZ '...`, -/// `TIMESTAMP_NTZ '...'`) are evaluated here, at analysis time, through -/// the same `CAST('...' AS TIMESTAMP)` kernels execution uses (so their -/// parsing rules match), with `options` supplying `spark.sql.timestampType` -/// (what plain `TIMESTAMP` means) and `spark.sql.session.timeZone` (for -/// instants without a zone). The result is a constant `Literal`, never a -/// per-row cast. +/// 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 { - lower(&parse_query(sql, options)?, source, options).map_err(|e| e.redacted_in(sql)) + lower(&parse_query(sql, options)?, source).map_err(|e| e.redacted_in(sql)) } /// Lowers `query` into an unresolved plan whose spans index `source`. /// -/// `options` supplies `spark.sql.timestampType` and -/// `spark.sql.session.timeZone` for typed timestamp literals (see -/// [`parse_and_lower`]). -/// /// # Errors /// `KRISHIV_UNSUPPORTED_FEATURE` for constructs the IR lacks, Spark's /// literal errors (`INVALID_NUMERIC_LITERAL_RANGE`, `INVALID_TYPED_LITERAL`, /// decimal bounds, unsupported cast types) and `FAILED_TO_PARSE_TOO_COMPLEX` /// for plans deeper than `MAX_DEPTH`. -pub fn lower(query: &Query, source: SourceId, options: &ParserOptions) -> R { +pub fn lower(query: &Query, source: SourceId) -> R { let mut l = Lowerer { source, depth: 0, root: query.span, windows: Vec::new(), - options: *options, }; let plan = l.query(query)?; Plan::try_new(plan).map_err(|e| err(e, query.span)) @@ -124,9 +110,6 @@ struct Lowerer { /// last; `None` stands for a subquery expression's boundary (Spark's /// `WindowsSubstitution` does not enter subquery plans). windows: Vec>>, - /// The session configs timestamp literals read (`spark.sql.timestampType` - /// and `spark.sql.session.timeZone`). - options: ParserOptions, } /// A `WINDOW` clause: each name's specification, references to other @@ -759,7 +742,7 @@ impl Lowerer { fn expr_inner(&mut self, e: &Expr) -> R { let sp = e.span; Ok(match &e.kind { - ExprKind::Literal(v) => self.ex(ExprNode::Literal(literal(v, sp, &self.options)?), sp), + ExprKind::Literal(v) => self.ex(literal(v, sp)?, sp), ExprKind::Keyword(k) => { self.ex(ExprNode::Literal(IrLiteral::String(k.value.clone())), sp) } @@ -1156,24 +1139,34 @@ fn is_path(s: &str) -> bool { s.contains('/') || s.contains(':') } -fn literal(v: &Literal, sp: Span, options: &ParserOptions) -> R { +fn literal(v: &Literal, sp: Span) -> R { 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))?, - ), - TypedKind::Timestamp | TypedKind::TimestampLtz | TypedKind::TimestampNtz => { - timestamp_literal(kind, value, options, sp)? - } + )), _ => { let t = type_name.value.to_ascii_uppercase(); return Err(unsupported(&format!("{t} literals"), sp)); @@ -1184,177 +1177,6 @@ fn literal(v: &Literal, sp: Span, options: &ParserOptions) -> R { }) } -/// A typed timestamp literal as Spark's `AstBuilder` builds it: the same -/// `CAST('...' AS TIMESTAMP)` kernels execution uses, evaluated once here -/// (a constant, never per row). -/// -/// Plain `TIMESTAMP` means `TIMESTAMP_NTZ` when -/// `spark.sql.timestampType = TIMESTAMP_NTZ` and the value names no zone, -/// else `TIMESTAMP_LTZ`. Values needing the query clock (`now`, `today`, -/// a bare time of day) or the tz 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, with the span -/// of the literal. -fn timestamp_literal( - kind: TypedKind, - value: &str, - options: &ParserOptions, - sp: Span, -) -> R { - use krishiv_kernels::cast::TimestampText; - use krishiv_kernels::cast::timestamp_text; - // Clock-dependent spellings evaluate with the query clock, which this - // layer has not got. - if literal::is_special(value) { - return Err(unsupported( - "a timestamp literal that needs the query clock", - sp, - )); - } - let shape = timestamp_text(value); - if shape == TimestampText::Malformed { - return Err(err(kind.invalid(value), sp)); - } - // 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 == TypedKind::TimestampNtz - || (kind == TypedKind::Timestamp && options.timestamp_ntz); - if without_zone { - return Err(err(kind.invalid(value), sp)); - } - return Err(unsupported( - "a timestamp literal that needs the query clock", - sp, - )); - } - match kind { - TypedKind::TimestampNtz => { - let micros = - cast_timestamp_ntz(value).map_err(|e| map_timestamp_error(e, kind, value, sp))?; - Ok(IrLiteral::TimestampNtz(micros)) - } - TypedKind::TimestampLtz => { - let micros = cast_timestamp_ltz(value, options.session_offset) - .map_err(|e| map_timestamp_error(e, kind, value, sp))?; - Ok(IrLiteral::Timestamp(micros)) - } - TypedKind::Timestamp if options.timestamp_ntz => { - // Under `TIMESTAMP_NTZ`, a value naming a zone is still an - // instant; without one it is wall-clock time. - if has_explicit_zone(value) { - let micros = cast_timestamp_ltz(value, options.session_offset) - .map_err(|e| map_timestamp_error(e, kind, value, sp))?; - Ok(IrLiteral::Timestamp(micros)) - } else { - let micros = cast_timestamp_ntz(value) - .map_err(|e| map_timestamp_error(e, kind, value, sp))?; - Ok(IrLiteral::TimestampNtz(micros)) - } - } - _ => { - let micros = cast_timestamp_ltz(value, options.session_offset) - .map_err(|e| map_timestamp_error(e, kind, value, sp))?; - Ok(IrLiteral::Timestamp(micros)) - } - } -} - -/// Whether `value` names an explicit zone: an instant whose `CAST` result -/// does not move with the session zone. Probed with the cast kernels -/// themselves (no second parser): the same value cast in two session zones -/// agrees exactly then. -fn has_explicit_zone(value: &str) -> bool { - let (Ok(a), Ok(b)) = ( - cast_one(value, <z_arrow(), &FixedOffset(0)), - cast_one(value, <z_arrow(), &FixedOffset(3600)), - ) else { - // Malformed or needing the tz database or clock: the caller maps - // the error; the zone question is moot. - return false; - }; - a == b -} - -/// The Arrow carrier of `TIMESTAMP`. -fn ltz_arrow() -> ArrowType { - ArrowType::Timestamp(TimeUnit::Microsecond, Some("UTC".into())) -} - -/// The Arrow carrier of `TIMESTAMP_NTZ`. -fn ntz_arrow() -> ArrowType { - ArrowType::Timestamp(TimeUnit::Microsecond, None) -} - -/// `value` cast as Spark casts `CAST(value AS TIMESTAMP_NTZ)`. -fn cast_timestamp_ntz(value: &str) -> Result { - let out = cast_one(value, &ntz_arrow(), &FixedOffset(0))?; - Ok(out) -} - -/// `value` cast as Spark casts `CAST(value AS TIMESTAMP)` in `session`. -/// `None` (a region session zone, or unset) serves values with an explicit -/// zone; values without one need the zone and are unsupported there. -fn cast_timestamp_ltz(value: &str, session: Option) -> Result { - // Session-independent values (an explicit offset) evaluate under any - // zone; only session-dependent ones read `session`. - let probe = cast_one(value, <z_arrow(), &FixedOffset(0)); - let probe2 = cast_one(value, <z_arrow(), &FixedOffset(3600)); - match (probe, probe2) { - (Ok(a), Ok(b)) if a == b => Ok(a), - (Ok(_), Ok(_)) => match session { - Some(off) => cast_one(value, <z_arrow(), &FixedOffset(off)), - None => Err(KrishivUnsupportedFeature { - feature: "a timestamp literal in a session time zone other than a fixed offset" - .to_owned(), - } - .into()), - }, - (Ok(a), Err(_)) => Ok(a), - (Err(e), _) => Err(e), - } -} - -/// One string cast through the kernels, as a microsecond instant or NTZ -/// wall-clock value. -fn cast_one(value: &str, to: &ArrowType, zone: &FixedOffset) -> Result { - 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(KrishivUnsupportedFeature { - feature: "a timestamp literal".to_owned(), - } - .into()); - } - Ok(out.as_primitive::().value(0)) -} - -/// A cast failure as the literal's error: malformed text is -/// `INVALID_TYPED_LITERAL` at the literal; anything needing the tz database -/// or clock stays `KRISHIV_UNSUPPORTED_FEATURE`. -fn map_timestamp_error(e: KrishivError, kind: TypedKind, value: &str, sp: Span) -> ParseError { - if e.error_class() == ErrorClass::KrishivUnsupportedFeature { - return err(e, sp); - } - err(kind.invalid(value), sp) -} - -/// The literal lowering, for tests of timestamp literals without parsing a -/// whole query. -#[cfg(test)] -pub(crate) fn literal_for_tests(v: &Literal, sp: Span, options: &ParserOptions) -> R { - literal(v, sp, options) -} - /// A numeric literal as Spark's `AstBuilder` types it. fn number(text: &str, kind: NumKind, sp: Span) -> R { Ok(match literal::number(text, kind).map_err(|e| err(e, sp))? { diff --git a/crates/krishiv-sql/src/tests.rs b/crates/krishiv-sql/src/tests.rs index 67dd848f..a708f364 100644 --- a/crates/krishiv-sql/src/tests.rs +++ b/crates/krishiv-sql/src/tests.rs @@ -954,135 +954,68 @@ fn multipart_identifiers_parse_like_spark() { assert_eq!(e.error.error_class(), ErrorClass::ParseEmptyStatement); } -/// Typed datetime literals lower through the `CAST` kernels, once, with the -/// session zone and `spark.sql.timestampType`. +/// 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_timestamp_literals_lower_like_cast() { +fn typed_datetime_literals_lower_unresolved() { use crate::ast::{ExprKind, SetExprKind}; - use krishiv_plan::{Literal as IrLiteral, SourceId}; + use krishiv_plan::SourceId; - let utc = ParserOptions { - session_offset: Some(0), - ..ParserOptions::default() - }; - let plus5 = ParserOptions { - session_offset: Some(5 * 3600 + 30 * 60), - ..ParserOptions::default() - }; - let ntz = ParserOptions { - timestamp_ntz: true, - session_offset: Some(0), - ..ParserOptions::default() - }; - let region = ParserOptions { - session_offset: None, - ..ParserOptions::default() - }; - let lit = |sql: &str, options: &ParserOptions| { - let q = parser::parse_query_unchecked(sql, *options).unwrap(); + // 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(v) = s.projection[0].expr.kind.clone() else { - panic!("{sql} is not a literal"); + let ExprKind::Literal(crate::ast::Literal::Typed { type_name, value }) = + s.projection[0].expr.kind.clone() + else { + panic!("{sql} is not a typed literal"); }; - crate::lower::literal_for_tests(&v, s.projection[0].expr.span, options) - }; - // `2024-01-01 10:00:00` in UTC is 10:00 UTC. - assert_eq!( - lit("SELECT TIMESTAMP '2024-01-01 10:00:00'", &utc).unwrap(), - IrLiteral::Timestamp(1_704_103_200_000_000) - ); - // The same wall-clock time in +05:30 is 04:30 UTC. - assert_eq!( - lit("SELECT TIMESTAMP '2024-01-01 10:00:00'", &plus5).unwrap(), - IrLiteral::Timestamp(1_704_083_400_000_000) - ); - // Explicit offsets ignore the session zone. - assert_eq!( - lit("SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'", &utc).unwrap(), - IrLiteral::Timestamp(1_704_083_400_000_000) - ); - assert_eq!( - lit("SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'", &plus5).unwrap(), - IrLiteral::Timestamp(1_704_083_400_000_000) - ); - // `TIMESTAMP_LTZ` is always an instant. - assert_eq!( - lit("SELECT TIMESTAMP_LTZ '2024-01-01 10:00:00'", &utc).unwrap(), - IrLiteral::Timestamp(1_704_103_200_000_000) - ); - // `TIMESTAMP_NTZ` is wall-clock time, the zone ignored. - assert_eq!( - lit("SELECT TIMESTAMP_NTZ '2024-01-01 10:00:00'", &utc).unwrap(), - IrLiteral::TimestampNtz(1_704_103_200_000_000) - ); - assert_eq!( - lit("SELECT TIMESTAMP_NTZ '2024-01-01 10:00:00+05:30'", &utc).unwrap(), - IrLiteral::TimestampNtz(1_704_103_200_000_000) - ); - // Plain `TIMESTAMP` under `TIMESTAMP_NTZ` is wall-clock without a zone, - // an instant with one. - assert_eq!( - lit("SELECT TIMESTAMP '2024-01-01 10:00:00'", &ntz).unwrap(), - IrLiteral::TimestampNtz(1_704_103_200_000_000) - ); - assert_eq!( - lit("SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'", &ntz).unwrap(), - IrLiteral::Timestamp(1_704_083_400_000_000) - ); - // Invalid text is `INVALID_TYPED_LITERAL` at the literal. - for (sql, options) in [ - ("SELECT TIMESTAMP '2024-13-01 10:00:00'", &utc), - ("SELECT TIMESTAMP_NTZ '10:00'", &utc), - ("SELECT TIMESTAMP '10:00'", &ntz), - ("SELECT TIMESTAMP_LTZ 'not-a-date'", &utc), - ] { - let e = lit(sql, options).unwrap_err(); - assert_eq!( - e.error.error_class(), - ErrorClass::InvalidTypedLiteral, - "{sql}" - ); - assert_eq!(e.span.range(), 7..sql.len(), "{sql}"); + 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}"); } - // A region session zone serves explicit offsets but not wall-clock time. - assert!(lit("SELECT TIMESTAMP '2024-01-01 10:00:00+05:30'", ®ion).is_ok()); - let e = lit("SELECT TIMESTAMP '2024-01-01 10:00:00'", ®ion).unwrap_err(); - assert_eq!(e.error.error_class(), ErrorClass::KrishivUnsupportedFeature); - assert!(e.error.to_string().contains("session time zone"), "{e}"); - // Clock-dependent spellings need the query clock. - for sql in [ - "SELECT TIMESTAMP 'now'", - "SELECT TIMESTAMP_LTZ '10:00'", - "SELECT TIMESTAMP '10:00'", - ] { - let e = lit(sql, &utc).unwrap_err(); - assert_eq!( - e.error.error_class(), - ErrorClass::KrishivUnsupportedFeature, - "{sql}" - ); - assert!(e.error.to_string().contains("query clock"), "{sql}: {e}"); - } - // `parse_and_lower` evaluates once (a constant): the plan holds a - // literal, not a cast. - let plan = crate::parse_and_lower("SELECT TIMESTAMP '2024-01-01 10:00:00'", &utc, SourceId(0)) - .unwrap(); - assert!(plan.root().to_string().contains("1704103200000000")); - // The session configs flow through `from_conf`. - let opts = ParserOptions::from_conf(|k| { - [ - ("spark.sql.timestampType", "TIMESTAMP_NTZ"), - ("spark.sql.session.timeZone", "+05:30"), - ] - .iter() - .find(|(key, _)| *key == k) - .map(|(_, v)| *v) - }); - assert!(opts.timestamp_ntz); - assert_eq!(opts.session_offset, Some(19_800)); - let default = ParserOptions::from_conf(|_| None); - assert!(!default.timestamp_ntz); - assert_eq!(default.session_offset, None); + // 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}"); } diff --git a/crates/krishiv-sql/src/validate/literal.rs b/crates/krishiv-sql/src/validate/literal.rs index 2e501a8e..b7ca2e4a 100644 --- a/crates/krishiv-sql/src/validate/literal.rs +++ b/crates/krishiv-sql/src/validate/literal.rs @@ -228,7 +228,7 @@ fn is_no_break_space(c: char) -> bool { /// The special values of `DATE` and `TIMESTAMP` literals (`now`, /// `epoch`, ...), which depend on the session's clock and zone. -pub(crate) fn is_special(value: &str) -> bool { +fn is_special(value: &str) -> bool { let v = value.trim().to_ascii_lowercase(); ["epoch", "now", "today", "yesterday", "tomorrow"].contains(&v.as_str()) } diff --git a/crates/krishiv-sql/tests/analyzer.rs b/crates/krishiv-sql/tests/analyzer.rs index e0d61ada..83291622 100644 --- a/crates/krishiv-sql/tests/analyzer.rs +++ b/crates/krishiv-sql/tests/analyzer.rs @@ -527,26 +527,29 @@ fn window_goldens_resolve_to_a_fixed_point() { assert!(failures.is_empty(), "{}", failures.join("\n")); } -/// Typed datetime literals resolve to Spark's types and names: plain -/// `TIMESTAMP` follows `spark.sql.timestampType` (and a zone in the value), -/// and instants without a zone read the session zone. The golden files +/// 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, offset: Option| { - let options = ParserOptions { + let analyze_with = |sql: &str, timestamp_ntz: bool, zone: Option| { + let conf = ResolutionConf { timestamp_ntz, - session_offset: offset, - ..ParserOptions::default() + session_zone: zone, + ..ResolutionConf::default() }; - let plan = parse_and_lower(sql, &options, SourceId(0)).map_err(|e| AnalysisError { - error: e.error, - origin: krishiv_plan::Origin::UNKNOWN, + 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), ResolutionConf::default()))) + 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`. @@ -576,6 +579,18 @@ fn typed_timestamp_literals_resolve_like_spark() { 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 [ ( @@ -594,4 +609,52 @@ fn typed_timestamp_literals_resolve_like_spark() { 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'", + ] { + 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" + ); } 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 26f93ccd..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 a timestamp literal in a session time zone other than a fixed offset 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 From 10829133c82fa67e1efb0928ced1d4ed3729329b Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Fri, 23 Oct 2026 19:21:20 +0200 Subject: [PATCH 3/4] kernels: one session-zone parser shared by the analyzer and execution The analyzer and the expression evaluator each carried a copy of the fixed-offset zone parser. Both now use FixedOffset::parse next to the zone type in the cast kernels, so typed literals and casts read spark.sql.session.timeZone the same way. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- crates/krishiv-exec/src/planner/eval/mod.rs | 21 +------- crates/krishiv-kernels/src/cast/datetime.rs | 54 +++++++++++++++++++++ crates/krishiv-plan/src/analyzer/mod.rs | 24 +-------- 3 files changed, 56 insertions(+), 43 deletions(-) diff --git a/crates/krishiv-exec/src/planner/eval/mod.rs b/crates/krishiv-exec/src/planner/eval/mod.rs index 2ea00bba..2f3beba2 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 { - 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/datetime.rs b/crates/krishiv-kernels/src/cast/datetime.rs index 3cd54a36..87d7e2ce 100644 --- a/crates/krishiv-kernels/src/cast/datetime.rs +++ b/crates/krishiv-kernels/src/cast/datetime.rs @@ -39,6 +39,32 @@ 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 { + 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, 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(|| Self(sign * (h * 3600 + m * 60))) + } +} + /// 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 { @@ -143,6 +169,34 @@ pub(crate) fn utc_to_local(utc: i64, tz: &dyn TimeZoneRules) -> Option { 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)), + ] { + 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", + ] { + 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-plan/src/analyzer/mod.rs b/crates/krishiv-plan/src/analyzer/mod.rs index fd960adc..7402756b 100644 --- a/crates/krishiv-plan/src/analyzer/mod.rs +++ b/crates/krishiv-plan/src/analyzer/mod.rs @@ -198,34 +198,12 @@ impl ResolutionConf { .is_some_and(|s| s.trim().eq_ignore_ascii_case("TIMESTAMP_NTZ")), session_zone: match conf(Self::KEYS[9]) { None => Some(0), - Some(s) => fixed_offset(s), + Some(s) => krishiv_kernels::cast::FixedOffset::parse(s).map(|o| o.0), }, } } } -/// The offset of `UTC`, `GMT`, `Z` or `[+-]hh:mm`, in seconds east of UTC; -/// `None` for region ids (which need the time-zone database) and malformed -/// zones. -fn fixed_offset(zone: &str) -> Option { - let zone = zone.trim(); - 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)) -} - /// Everything resolution may read. #[derive(Clone)] pub struct AnalysisContext { From 7cae657f3267d3a20b3f670c198bec78dc380f4b Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Sat, 24 Oct 2026 07:29:10 +0200 Subject: [PATCH 4/4] Address review findings on typed datetime literals and session zones Strict session-zone parsing to 1-2 ASCII digits per field with the total capped at 18 hours. DATE with time-only text reports INVALID_TYPED_LITERAL. Session-zone tests assert exact timestamp micros for both zones. Manifests updated for timestamp literals that now resolve. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- crates/krishiv-kernels/src/cast/datetime.rs | 24 +- crates/krishiv-plan/src/analyzer/exprs.rs | 3 +- crates/krishiv-plan/src/tests/analyzer.rs | 28 +- crates/krishiv-sql/tests/analyzer.rs | 29 +- .../analysis/registry-matrix-manifest.json | 3116 +---------------- .../analysis/type-coercion-manifest.json | 2 +- 6 files changed, 250 insertions(+), 2952 deletions(-) diff --git a/crates/krishiv-kernels/src/cast/datetime.rs b/crates/krishiv-kernels/src/cast/datetime.rs index 87d7e2ce..dc355052 100644 --- a/crates/krishiv-kernels/src/cast/datetime.rs +++ b/crates/krishiv-kernels/src/cast/datetime.rs @@ -59,9 +59,19 @@ impl FixedOffset { 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(|| Self(sign * (h * 3600 + m * 60))) + 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)) } } @@ -180,6 +190,7 @@ mod tests { ("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}"); } @@ -192,6 +203,13 @@ mod tests { "+05:60", "+ab", "UTC*1", + "++5", + "+05:+30", + "+18:30", + "+18:01", + "-18:30", + "+5:30:00", + "+", ] { assert_eq!(FixedOffset::parse(zone), None, "{zone}"); } diff --git a/crates/krishiv-plan/src/analyzer/exprs.rs b/crates/krishiv-plan/src/analyzer/exprs.rs index 59e3dd97..925547e0 100644 --- a/crates/krishiv-plan/src/analyzer/exprs.rs +++ b/crates/krishiv-plan/src/analyzer/exprs.rs @@ -324,7 +324,8 @@ fn typed_literal( // 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::TimestampNtz + let without_zone = kind == TypedLiteralKind::Date + || kind == TypedLiteralKind::TimestampNtz || (kind == TypedLiteralKind::Timestamp && conf.timestamp_ntz); if without_zone { return Err(invalid(type_name)); diff --git a/crates/krishiv-plan/src/tests/analyzer.rs b/crates/krishiv-plan/src/tests/analyzer.rs index c0797182..ca8d2055 100644 --- a/crates/krishiv-plan/src/tests/analyzer.rs +++ b/crates/krishiv-plan/src/tests/analyzer.rs @@ -1931,7 +1931,7 @@ fn try_arithmetic_casts_its_arguments_in_try_mode() { /// Typed datetime literals resolve in the analyzer with the session zone. #[test] fn typed_literals_resolve_with_the_session_zone() { - use crate::{ExprNode, LogicalPlan, Plan, TypedLiteralKind}; + use crate::{ExprNode, Literal, LogicalPlan, Plan, PlanNode, ResolvedExpr, TypedLiteralKind}; let project = |kind: TypedLiteralKind, value: &str, conf: ResolutionConf| { let expr = Expr::new(ExprNode::TypedLiteral { kind, @@ -1945,6 +1945,21 @@ fn typed_literals_resolve_with_the_session_zone() { 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() @@ -1977,13 +1992,13 @@ fn typed_literals_resolve_with_the_session_zone() { ) .unwrap(); assert_eq!(a.output[0].data_type.simple_string(), "timestamp"); - // The session zone moves wall-clock instants; names render in it. + // 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_ne!( - utc_plan.plan.root().to_string(), - plus_plan.plan.root().to_string() - ); + 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", @@ -2001,6 +2016,7 @@ fn typed_literals_resolve_with_the_session_zone() { (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!( diff --git a/crates/krishiv-sql/tests/analyzer.rs b/crates/krishiv-sql/tests/analyzer.rs index 83291622..e6868b72 100644 --- a/crates/krishiv-sql/tests/analyzer.rs +++ b/crates/krishiv-sql/tests/analyzer.rs @@ -20,8 +20,8 @@ use krishiv_plan::analyzer::{ ResolutionConf, TableColumn, }; use krishiv_plan::{ - AttrId, Builtin, Expr, ExprNode, FunctionId, JoinCondition, JoinKind, LogicalPlan, PlanNode, - ResolvedExpr, SourceId, + AttrId, Builtin, Expr, ExprNode, FunctionId, JoinCondition, JoinKind, Literal, LogicalPlan, + PlanNode, ResolvedExpr, SourceId, }; use krishiv_sql::{ParserOptions, parse_and_lower, redact_sql}; use serde_json::Value; @@ -562,7 +562,9 @@ fn typed_timestamp_literals_resolve_like_spark() { // ... 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). + // 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'", @@ -570,10 +572,22 @@ fn typed_timestamp_literals_resolve_like_spark() { Some(19_800), ) .unwrap(); - assert_ne!( - utc_plan.plan.root().to_string(), - plus_plan.plan.root().to_string() - ); + 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"); @@ -614,6 +628,7 @@ fn typed_timestamp_literals_resolve_like_spark() { "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!( diff --git a/tests/fixtures/analysis/registry-matrix-manifest.json b/tests/fixtures/analysis/registry-matrix-manifest.json index 6a3e7a0b..81f05b62 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,53 +1689,13 @@ "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" + "reason": "SELECT date_part(CAST(NULL AS string), TIMESTAMP '2019-08-12 01:00:00.123456') | NON_FOLDABLE_ARGUMENT" }, { "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" + "reason": "SELECT date_part(CAST(NULL AS string), TIMESTAMP '2019-08-12 01:00:00.123456') | NON_FOLDABLE_ARGUMENT" }, { "id": "date_part#4e04c424a4c6/ansi_off", @@ -2369,38 +1705,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 +1713,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 +1721,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 +1737,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 +1763,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 +1777,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 +1785,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 +1801,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 +1817,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 +1889,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 +1905,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 +1921,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 +1945,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 +1969,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 +1977,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 +1993,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 +2001,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 +2033,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 +2097,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 +2113,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 +2121,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 +2145,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 +2177,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 +2185,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 +2233,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 +2265,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 +2297,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 +2329,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 +2337,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 +2385,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 +2841,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 +2849,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 +2913,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 +2937,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 +2985,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" @@ -4145,22 +3033,6 @@ "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#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#69f9244398a6/ansi_off", "reason": "SELECT greatest(10, 9, 2, 4, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -4177,14 +3049,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 +3073,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 +3105,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 +3137,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 +3145,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 +3179,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 +3283,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 +3371,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 +3385,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 +3499,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 +3577,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 +3673,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 +3689,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 +3697,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 +3705,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 +3745,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 +3753,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 +3801,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 +3809,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 +3817,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 +3843,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 +4003,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 +4049,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 +4489,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 +4505,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 +4537,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 +4561,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 +4577,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 +4657,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 +4665,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 +4673,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 +4697,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 +4721,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 +4729,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" @@ -6143,31 +4759,15 @@ }, { "id": "length#c6d96388bc9a/ansi_on", - "reason": "SELECT length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "length#c9aa4be9c045/ansi_off", - "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#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" + "reason": "SELECT length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL 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": "length#c9aa4be9c045/ansi_off", + "reason": "SELECT length(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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": "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": "ln#20f59312532d/ansi_off", @@ -6177,14 +4777,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 +4809,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 +4817,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 +4865,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 +4913,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 +4929,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 +4937,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 +4953,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 +4985,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 +5009,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 +5017,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 +5033,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 +5057,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 +5105,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 +5145,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 +5169,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 +5225,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 +5265,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 +5289,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 +5305,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 +5329,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 +5345,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 +5361,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 +5409,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 +5441,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 +5565,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 +5585,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 +5617,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 +5657,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 +5673,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 +5713,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" @@ -7649,14 +5953,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" @@ -7673,22 +5969,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" @@ -7713,14 +5993,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" @@ -7761,14 +6033,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" @@ -7777,14 +6041,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" @@ -7881,21 +6137,13 @@ "id": "nvl#41a41efe1197/ansi_on", "reason": "SELECT nvl(NULL, CAST(NULL AS array)) | 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", @@ -7977,14 +6225,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" @@ -7995,11 +6235,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", @@ -8073,14 +6313,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" @@ -8137,30 +6369,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" @@ -8169,14 +6377,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" @@ -8201,14 +6401,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" @@ -8229,14 +6421,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" @@ -8281,22 +6465,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" @@ -8313,14 +6481,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" @@ -8353,14 +6513,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" @@ -8369,14 +6521,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" @@ -8425,14 +6569,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" @@ -8473,22 +6609,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" @@ -8497,14 +6617,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" @@ -8523,19 +6635,11 @@ }, { "id": "power#1fb3cb5e732f/ansi_off", - "reason": "SELECT power(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "power#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" + "reason": "SELECT power(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array 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#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#50aa498e03a3/ansi_off", @@ -8593,14 +6697,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" @@ -8609,14 +6705,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" @@ -8625,14 +6713,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" @@ -8641,14 +6721,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" @@ -8665,14 +6737,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" @@ -8745,14 +6809,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" @@ -8761,14 +6817,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" @@ -8785,14 +6833,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" @@ -8809,22 +6849,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" @@ -8833,14 +6857,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" @@ -8865,14 +6881,6 @@ "id": "regexp_replace#fb71844662a3/ansi_on", "reason": "SELECT regexp_replace(array(1, 2), '(\\\\d+)', 'num') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "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" @@ -8889,30 +6897,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" @@ -8929,14 +6913,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" @@ -8969,14 +6945,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" @@ -9049,22 +7017,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" @@ -9089,14 +7041,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" @@ -9113,14 +7057,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" @@ -9169,14 +7105,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" @@ -9193,14 +7121,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" @@ -9281,14 +7201,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" @@ -9321,14 +7233,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" @@ -9353,14 +7257,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" @@ -9417,14 +7313,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" @@ -9489,14 +7377,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" @@ -9505,14 +7385,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" @@ -9529,38 +7401,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" @@ -9585,14 +7425,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" @@ -9601,14 +7433,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" @@ -9665,22 +7489,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" @@ -9705,14 +7513,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" @@ -9729,14 +7529,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" @@ -9761,22 +7553,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" @@ -9817,22 +7593,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" @@ -9849,14 +7609,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" @@ -9889,14 +7641,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" @@ -9913,14 +7657,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" @@ -9977,22 +7713,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" @@ -10049,14 +7769,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" @@ -10065,14 +7777,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" @@ -10081,14 +7785,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" @@ -10113,14 +7809,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" @@ -10129,14 +7817,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" @@ -10177,14 +7857,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" @@ -10209,14 +7881,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" @@ -10273,22 +7937,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" @@ -10297,22 +7945,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" @@ -10375,39 +8007,15 @@ }, { "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" - }, - { - "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" + "reason": "SELECT substr('Spark SQL', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { - "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#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" }, { - "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#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#33fcc8cec89e/ansi_off", @@ -10433,14 +8041,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" @@ -10465,22 +8065,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" @@ -10513,22 +8097,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" @@ -10569,22 +8137,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" @@ -10649,30 +8201,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" @@ -10689,14 +8217,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" @@ -10745,14 +8265,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" @@ -10809,14 +8321,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" @@ -10825,14 +8329,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" @@ -10841,14 +8337,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" @@ -10865,22 +8353,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" @@ -10985,22 +8457,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" @@ -11025,22 +8481,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" @@ -11073,22 +8513,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" @@ -11139,11 +8563,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", @@ -11155,19 +8579,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", @@ -11183,11 +8607,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", @@ -11239,11 +8663,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", @@ -11303,11 +8727,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", @@ -11315,19 +8739,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", @@ -11379,11 +8803,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", @@ -11409,14 +8833,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" @@ -11429,14 +8845,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" @@ -11505,22 +8913,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\")" @@ -11605,42 +8997,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" @@ -11697,14 +9057,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\")" @@ -11737,14 +9089,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" @@ -11761,14 +9105,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" @@ -11809,14 +9145,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" @@ -11831,19 +9159,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", @@ -11855,11 +9183,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", @@ -11903,11 +9231,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", @@ -11983,27 +9311,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", @@ -12015,11 +9343,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", @@ -12059,11 +9387,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", @@ -12105,14 +9433,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" @@ -12129,14 +9449,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" @@ -12153,14 +9465,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" @@ -12169,14 +9473,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" @@ -12243,11 +9539,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", @@ -12299,19 +9595,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", @@ -12337,14 +9633,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" @@ -12489,14 +9777,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" @@ -12571,11 +9851,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", @@ -12681,14 +9961,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" @@ -12705,14 +9977,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" @@ -12745,14 +10009,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" @@ -12784,14 +10040,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, @@ -12799,42 +10047,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, @@ -12844,62 +10092,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, @@ -12909,12 +10157,12 @@ { "cases": 54, "function": "crc32", - "pass": 40 + "pass": 44 }, { "cases": 48, "function": "csc", - "pass": 34 + "pass": 38 }, { "cases": 2, @@ -12944,47 +10192,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": 94 }, { "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, @@ -12999,22 +10247,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, @@ -13029,32 +10277,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, @@ -13069,22 +10317,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, @@ -13094,37 +10342,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, @@ -13134,7 +10382,7 @@ { "cases": 54, "function": "md5", - "pass": 40 + "pass": 44 }, { "cases": 10, @@ -13149,17 +10397,17 @@ { "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": 2, @@ -13174,22 +10422,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, @@ -13204,27 +10452,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, @@ -13234,22 +10482,22 @@ { "cases": 160, "function": "regexp_replace", - "pass": 118 + "pass": 130 }, { "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, @@ -13259,17 +10507,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, @@ -13279,57 +10527,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, @@ -13339,17 +10587,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, @@ -13359,17 +10607,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, @@ -13379,12 +10627,12 @@ { "cases": 54, "function": "ucase", - "pass": 40 + "pass": 44 }, { "cases": 54, "function": "upper", - "pass": 40 + "pass": 44 }, { "cases": 2, @@ -13394,18 +10642,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": 6068 + "pass": 6756 } 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",