diff --git a/Cargo.lock b/Cargo.lock index b045cd066..3ffe408f0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1541,6 +1541,7 @@ name = "krishiv-functions" version = "0.1.0-alpha" dependencies = [ "arrow-array", + "arrow-buffer", "arrow-schema", "arrow-select", "fancy-regex", diff --git a/crates/krishiv-cli/src/sql.rs b/crates/krishiv-cli/src/sql.rs index 2f80a5c0b..24ad12c04 100644 --- a/crates/krishiv-cli/src/sql.rs +++ b/crates/krishiv-cli/src/sql.rs @@ -484,6 +484,24 @@ fn cell(a: &dyn Array, i: usize, null: &str, tz: i64) -> String { .collect(); format!("{{{}}}", items.join(", ")) } + DataType::Map(_, _) => { + let m = a.as_map(); + let offsets = m.value_offsets(); + let (from, to) = ( + usize::try_from(offsets[i]).unwrap_or(0), + usize::try_from(offsets[i + 1]).unwrap_or(0), + ); + let items: Vec = (from..to) + .map(|j| { + format!( + "{} -> {}", + cell(m.keys().as_ref(), j, "NULL", tz), + cell(m.values().as_ref(), j, "NULL", tz) + ) + }) + .collect(); + format!("{{{}}}", items.join(", ")) + } other => format!("<{other}>"), } } @@ -591,6 +609,20 @@ mod tests { Arc::new(Field::new("x", DataType::Int32, true)), arr(Int32Array::from(vec![7])), )]); + let mut mb = krishiv::arrow::array::builder::MapBuilder::new( + None, + krishiv::arrow::array::builder::StringBuilder::new(), + krishiv::arrow::array::builder::Int32Builder::new(), + ); + mb.keys().append_value("a"); + mb.values().append_value(1); + mb.keys().append_value("b"); + mb.values().append_null(); + mb.append(true).expect("map entry"); + mb.append(true).expect("empty map"); + let map = mb.finish(); + assert_eq!(cell(&map, 0, "NULL", 0), "{a -> 1, b -> NULL}"); + assert_eq!(cell(&map, 1, "NULL", 0), "{}"); let cases: Vec<(ArrayRef, &str)> = vec![ (arr(BooleanArray::from(vec![true])), "true"), (arr(UInt8Array::from(vec![5])), "5"), diff --git a/crates/krishiv-common/src/config/registry.rs b/crates/krishiv-common/src/config/registry.rs index 1b67d1dce..35d7042d1 100644 --- a/crates/krishiv-common/src/config/registry.rs +++ b/crates/krishiv-common/src/config/registry.rs @@ -13,6 +13,7 @@ pub static REGISTRY: &[&ConfigEntry] = &[ &ANSI_ENABLED, &SESSION_TIME_ZONE, &STORE_ASSIGNMENT_POLICY, + &MAP_KEY_DEDUP_POLICY, &TARGET_PARTITION_BYTES, &EXEC_BATCH_SIZE, &EXEC_AGG_ROW_LAYOUT, @@ -93,6 +94,7 @@ pub static INDEX: &[(&str, &ConfigEntry)] = &[ ("spark.sql.session.timeZone", &SESSION_TIME_ZONE), ("krishiv.exec.join.radixBits", &EXEC_JOIN_RADIX_BITS), ("krishiv.exec.join.rowLayout", &EXEC_JOIN_ROW_LAYOUT), + ("spark.sql.mapKeyDedupPolicy", &MAP_KEY_DEDUP_POLICY), ("krishiv.sql.session.timeZone", &SESSION_TIME_ZONE), ("spark.sql.shuffle.partitions", &SHUFFLE_PARTITIONS_HINT), ("krishiv.exec.sort.hashBuckets", &EXEC_SORT_HASH_BUCKETS), @@ -100,6 +102,7 @@ pub static INDEX: &[(&str, &ConfigEntry)] = &[ ("krishiv.io.multipartPartBytes", &IO_MULTIPART_PART_BYTES), ("krishiv.runtimeFilter.enabled", &RUNTIME_FILTER_ENABLED), ("krishiv.spill.dropBehindBytes", &SPILL_DROP_BEHIND_BYTES), + ("krishiv.sql.mapKeyDedupPolicy", &MAP_KEY_DEDUP_POLICY), ("krishiv.io.lateMaterialization", &IO_LATE_MATERIALIZATION), ( "krishiv.memory.spillWaitTimeout", @@ -263,6 +266,19 @@ pub static STORE_ASSIGNMENT_POLICY: ConfigEntry = ConfigEntry { spark_alias: Some("spark.sql.storeAssignmentPolicy"), }; +/// Map key deduplication policy. +pub static MAP_KEY_DEDUP_POLICY: ConfigEntry = ConfigEntry { + key: "krishiv.sql.mapKeyDedupPolicy", + value_type: ValueType::Enum(&["EXCEPTION", "LAST_WIN"]), + default: Some(ConfigValue::String(Cow::Borrowed("EXCEPTION"))), + doc: "How duplicate map keys are handled by the map functions (`map`, `map_concat`, \ + `map_from_arrays`, `map_from_entries`, `str_to_map`): `EXCEPTION` fails the query, \ + `LAST_WIN` keeps the value inserted last.", + scope: Scope::Session, + version_added: "0.1.0", + spark_alias: Some("spark.sql.mapKeyDedupPolicy"), +}; + /// Target partition size, replacing a fixed shuffle partition count. pub static TARGET_PARTITION_BYTES: ConfigEntry = ConfigEntry { key: "krishiv.exec.targetPartitionBytes", diff --git a/crates/krishiv-common/src/config/tests.rs b/crates/krishiv-common/src/config/tests.rs index 236d8e655..01f26494f 100644 --- a/crates/krishiv-common/src/config/tests.rs +++ b/crates/krishiv-common/src/config/tests.rs @@ -163,6 +163,31 @@ fn spill_entries_parse_and_default() { assert!(c.set("krishiv.spill.maxBytes", "lots").is_err()); } +#[test] +fn map_key_dedup_policy_parses_and_defaults() { + let mut c = Config::new(); + assert_eq!( + c.get(&MAP_KEY_DEDUP_POLICY).and_then(ConfigValue::as_str), + Some("EXCEPTION") + ); + c.set("krishiv.sql.mapKeyDedupPolicy", "LAST_WIN").unwrap(); + assert_eq!( + c.get(&MAP_KEY_DEDUP_POLICY).and_then(ConfigValue::as_str), + Some("LAST_WIN") + ); + // The Spark alias sets the same entry. + c.set("spark.sql.mapKeyDedupPolicy", "EXCEPTION").unwrap(); + assert_eq!( + c.get(&MAP_KEY_DEDUP_POLICY).and_then(ConfigValue::as_str), + Some("EXCEPTION") + ); + assert!(c.set("spark.sql.mapKeyDedupPolicy", "FIRST_WIN").is_err()); + assert_eq!( + c.get(&MAP_KEY_DEDUP_POLICY).and_then(ConfigValue::as_str), + Some("EXCEPTION") + ); +} + #[test] fn invalid_values_are_typed_errors() { let mut c = Config::new(); diff --git a/crates/krishiv-exec/src/physical/mod.rs b/crates/krishiv-exec/src/physical/mod.rs index ba3c2ce57..a837bbba8 100644 --- a/crates/krishiv-exec/src/physical/mod.rs +++ b/crates/krishiv-exec/src/physical/mod.rs @@ -204,6 +204,10 @@ pub struct ExprEnv { pub query_start_micros: i64, /// The session user (`current_user()`). pub user: Arc, + /// `spark.sql.mapKeyDedupPolicy = LAST_WIN`: duplicate map keys keep + /// the value inserted last. A plan that sets it needs the + /// `map_key_dedup_policy` codec feature. + pub map_key_dedup_last_win: bool, } /// A node of a physical plan. Children come first in each variant; @@ -546,7 +550,14 @@ plan_data!( Partitioned, } ); -plan_data!(struct ExprEnv { ansi, legacy_statistical_aggregate, zone, query_start_micros, user }); +plan_data!(struct ExprEnv { + ansi, + legacy_statistical_aggregate, + zone, + query_start_micros, + user, + map_key_dedup_last_win +}); plan_data!(enum PhysNode { Scan(scan), OneRow, diff --git a/crates/krishiv-exec/src/planner/eval/func.rs b/crates/krishiv-exec/src/planner/eval/func.rs index fae6ace1a..1883c2174 100644 --- a/crates/krishiv-exec/src/planner/eval/func.rs +++ b/crates/krishiv-exec/src/planner/eval/func.rs @@ -8,6 +8,7 @@ use arrow_array::RecordBatch; use arrow_schema::DataType as ArrowType; use krishiv_functions::scalar::{Arg, BindArg, BindOptions, ScalarFunction, bind_scalar}; use krishiv_kernels::cast::FixedOffset; +use krishiv_kernels::map::DedupPolicy; use krishiv_plan::{Expr, ExprNode, ResolvedFunction}; use super::strings::to_view; @@ -54,6 +55,11 @@ pub(super) fn compile( .with_kernel(input.env.kernels) .with_time_zone(Arc::new(zone)) .with_query_start(input.env.query_start_micros) + .with_map_key_dedup_policy(if input.env.map_key_dedup_last_win { + DedupPolicy::LastWin + } else { + DedupPolicy::Exception + }) .with_user(Arc::clone(&input.env.user)) .with_seed_salt(Arc::clone(&input.env.seed_salt)); let function = bind_scalar(name, &bind_args, &opts).map_err(|err| { diff --git a/crates/krishiv-exec/src/planner/eval/hof.rs b/crates/krishiv-exec/src/planner/eval/hof.rs index 97f07efa7..40ee604ed 100644 --- a/crates/krishiv-exec/src/planner/eval/hof.rs +++ b/crates/krishiv-exec/src/planner/eval/hof.rs @@ -447,6 +447,7 @@ mod tests { kernels: KernelCtx::new(), query_start_micros: 0, user: Arc::from("test"), + map_key_dedup_last_win: false, seed_salt: Arc::new(std::sync::atomic::AtomicU64::new(0)), } } diff --git a/crates/krishiv-exec/src/planner/eval/mod.rs b/crates/krishiv-exec/src/planner/eval/mod.rs index dd9f62221..ec0e97f8c 100644 --- a/crates/krishiv-exec/src/planner/eval/mod.rs +++ b/crates/krishiv-exec/src/planner/eval/mod.rs @@ -40,7 +40,7 @@ use arrow_array::cast::AsArray; use arrow_array::{Array, ArrayRef, BooleanArray, RecordBatch, UInt32Array, new_null_array}; use arrow_schema::{DataType as ArrowType, SchemaRef}; use krishiv_common::config::{ - ANSI_ENABLED, Config, LEGACY_STATISTICAL_AGGREGATE, SESSION_TIME_ZONE, + ANSI_ENABLED, Config, LEGACY_STATISTICAL_AGGREGATE, MAP_KEY_DEDUP_POLICY, SESSION_TIME_ZONE, }; use krishiv_kernels::KernelCtx; use krishiv_plan::{ @@ -178,6 +178,10 @@ pub(crate) struct EvalEnv { pub(crate) query_start_micros: i64, /// The session user (`current_user()`). pub(crate) user: Arc, + /// `spark.sql.mapKeyDedupPolicy = LAST_WIN`: duplicate map keys keep + /// the value inserted last. It travels in the plan (`ExprEnv`), so a + /// worker instantiating a plan without the feature refuses it. + pub(crate) map_key_dedup_last_win: bool, /// Counts the unseeded random binds of one plan instantiation (see /// [`BindOptions::seed_salt`](krishiv_functions::scalar::BindOptions::seed_salt)). pub(crate) seed_salt: Arc, @@ -197,6 +201,10 @@ impl EvalEnv { .get(&SESSION_TIME_ZONE) .and_then(|v| v.as_str()) .and_then(|z| krishiv_kernels::cast::FixedOffset::parse(z).map(|o| o.0)); + let map_key_dedup_last_win = config + .get(&MAP_KEY_DEDUP_POLICY) + .and_then(|v| v.as_str()) + .is_some_and(|s| s.eq_ignore_ascii_case("LAST_WIN")); let query_start_micros = std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .ok() @@ -209,6 +217,7 @@ impl EvalEnv { kernels: KernelCtx::new(), query_start_micros, user, + map_key_dedup_last_win, seed_salt: Arc::new(AtomicU64::new(0)), } } @@ -224,6 +233,7 @@ impl EvalEnv { kernels: KernelCtx::new(), query_start_micros: env.query_start_micros, user: Arc::clone(&env.user), + map_key_dedup_last_win: env.map_key_dedup_last_win, seed_salt: Arc::new(AtomicU64::new(0)), } } @@ -236,6 +246,7 @@ impl EvalEnv { zone: self.zone, query_start_micros: self.query_start_micros, user: Arc::clone(&self.user), + map_key_dedup_last_win: self.map_key_dedup_last_win, } } } diff --git a/crates/krishiv-exec/src/profile/tests.rs b/crates/krishiv-exec/src/profile/tests.rs index e704ea1ab..bea27ae07 100644 --- a/crates/krishiv-exec/src/profile/tests.rs +++ b/crates/krishiv-exec/src/profile/tests.rs @@ -21,6 +21,7 @@ fn env() -> ExprEnv { zone: Some(0), query_start_micros: 0, user: Arc::from("u"), + map_key_dedup_last_win: false, } } diff --git a/crates/krishiv-exec/tests/planner/physical.rs b/crates/krishiv-exec/tests/planner/physical.rs index 6b3f19c26..23365cf43 100644 --- a/crates/krishiv-exec/tests/planner/physical.rs +++ b/crates/krishiv-exec/tests/planner/physical.rs @@ -167,6 +167,7 @@ fn env_data() -> ExprEnv { zone: Some(0), query_start_micros: 0, user: Arc::from("u"), + map_key_dedup_last_win: false, } } diff --git a/crates/krishiv-exec/tests/planner/write.rs b/crates/krishiv-exec/tests/planner/write.rs index 7c84b5091..f0649ffbd 100644 --- a/crates/krishiv-exec/tests/planner/write.rs +++ b/crates/krishiv-exec/tests/planner/write.rs @@ -127,6 +127,7 @@ fn query_results_are_written_committed_and_read_back() { zone: None, query_start_micros: 0, user: Arc::from("u"), + map_key_dedup_last_win: false, }, ); let worker = WorkerContext::new(Arc::new(MemoryTables::new())).with_write_sink(other); diff --git a/crates/krishiv-functions/CLAUDE.md b/crates/krishiv-functions/CLAUDE.md index 190a69717..49ab718cc 100644 --- a/crates/krishiv-functions/CLAUDE.md +++ b/crates/krishiv-functions/CLAUDE.md @@ -23,8 +23,8 @@ Spark-compatible function library: scalar, aggregate, window and generator funct `Arc` (`return_type`, `invoke(&[Arg], rows)`), IR-free (Arrow types only) so the physical planner (krishiv-exec) calls it per batch. Arguments arrive after the analyzer's implicit casts; strings/binary in any Arrow carrier (read as `Utf8`/`Binary`), results in plain carriers. One family module per kernel family (`string`, `chars`, `codec`, - `datetime`, `math`, `arith`, `hash`, `session`, `regex`), each with `NAMES` and a `bind` over the argument shape. `BindOptions` holds ANSI, `KernelCtx` (Spark - version), session zone, the query start instant (`current_date`, `current_timestamp`, `localtimestamp`), the session user (`current_user`, `user`, `session_user`; family `session`) and `decimalOperations.allowPrecisionLoss`. `round`/`ceil`/`floor` bind + `datetime`, `math`, `arith`, `hash`, `session`, `regex`, `map`), each with `NAMES` and a `bind` over the argument shape. `BindOptions` holds ANSI, `KernelCtx` (Spark + version), session zone, the query start instant (`current_date`, `current_timestamp`, `localtimestamp`), the session user (`current_user`, `user`, `session_user`; family `session`), `decimalOperations.allowPrecisionLoss` and `spark.sql.mapKeyDedupPolicy` (the map family). `round`/`ceil`/`floor` bind their scale from a `BindArg::Literal`. Operators, `CAST` and aggregates are not bound here. - `python_wrappers`: generates `python/krishiv/sql/_generated_functions.py` and `.pyi` (PySpark names and parameters) from the @@ -41,7 +41,7 @@ Paths are relative to this crate. - `src/registry/conditional.rs` conditional evaluators; `src/registry/hashing.rs` hash signatures - `src/registry/catalog.rs` catalog rows loaded from `vendored/spark-functions.tsv` - `src/scalar/mod.rs` `bind_scalar`; `src/scalar/args.rs` argument handling shared by bindings -- `src/scalar/{string,chars,codec,datetime,math,arith,hash,session,regex}.rs` family bindings (`NAMES` and `bind`); `src/scalar/regex/java.rs` Java-to-`fancy_regex` translation +- `src/scalar/{string,chars,codec,datetime,math,arith,hash,map,session,regex}.rs` family bindings (`NAMES` and `bind`); `src/scalar/regex/java.rs` Java-to-`fancy_regex` translation - `vendored/spark-functions.tsv` generated from Spark runs; never edit by hand ## Extension points @@ -106,6 +106,6 @@ Paths are relative to this crate. (`spark.sql.legacy.javaCharsets` and `...codingErrorAction` are not read) and report unmappable input. `split_part`/`substring_index` with `Int.MIN` return the algorithm's value where the JVM raises; `initcap`/`mask` classify non-ASCII with the toolchain's Unicode data (pinned by `toolchain_unicode_is_pinned`). A string is always valid UTF-8 here, so the validators only fail on `binary` input. - Not implemented (`KnownUnsupported`): `format_string`/`printf`, `parse_url`/`try_parse_url`, `sentences`, `split`, `str_to_map` - (array/map results or a Java formatter), `collate`/`collation`/`collations`, `randstr` (no seeded random source), and the + Not implemented (`KnownUnsupported`): `format_string`/`printf`, `parse_url`/`try_parse_url`, `sentences`, `split` + (array results or a Java formatter), `collate`/`collation`/`collations`, `randstr` (no seeded random source), and the `decode(expr, search, result, ...)` form (analysis error `KRISHIV_UNSUPPORTED_FEATURE`). diff --git a/crates/krishiv-functions/Cargo.toml b/crates/krishiv-functions/Cargo.toml index 0aea28593..53b1a747c 100644 --- a/crates/krishiv-functions/Cargo.toml +++ b/crates/krishiv-functions/Cargo.toml @@ -34,3 +34,6 @@ ignored = ["regex-automata", "regex-syntax"] [lints] workspace = true + +[dev-dependencies] +arrow-buffer.workspace = true diff --git a/crates/krishiv-functions/src/python_wrappers/mod.rs b/crates/krishiv-functions/src/python_wrappers/mod.rs index 953b0fe49..a9fab59aa 100644 --- a/crates/krishiv-functions/src/python_wrappers/mod.rs +++ b/crates/krishiv-functions/src/python_wrappers/mod.rs @@ -299,6 +299,19 @@ fn render_function(row: &Row, params: &[Param]) -> (String, String) { if let Some(message) = row.deprecated { body.push_str(&format!(" _deprecated(\"{message}\")\n")); } + if row.py == "str_to_map" { + // PySpark sends the default pair delimiter when only `keyValueDelim` + // is given, so the third argument keeps its position. + body.push_str(" if pairDelim is None and keyValueDelim is not None:\n"); + let defaulted = vec![ + format!("\"{}\"", row.registry), + "_named(text, \"text\")".to_owned(), + "_lit(\",\", \"pairDelim\")".to_owned(), + "_named(keyValueDelim, \"keyValueDelim\")".to_owned(), + ]; + body.push_str(&wrap(" return _call(", &defaulted, ")", 8)); + body.push('\n'); + } body.push_str(&wrap(" return _call(", &args, ")", 4)); body.push('\n'); let def = format!("{}\n{body}", wrap(&head, &declarations, ") -> Column:", 0)); diff --git a/crates/krishiv-functions/src/python_wrappers/table.rs b/crates/krishiv-functions/src/python_wrappers/table.rs index bf74045c6..65ecdf622 100644 --- a/crates/krishiv-functions/src/python_wrappers/table.rs +++ b/crates/krishiv-functions/src/python_wrappers/table.rs @@ -147,6 +147,10 @@ pub(super) fn rows() -> Vec { "log1p", "log2", "lower", + "map_entries", + "map_from_entries", + "map_keys", + "map_values", "max", "md5", "min", @@ -284,6 +288,7 @@ pub(super) fn rows() -> Vec { "array", "coalesce", "hash", + "map_concat", "named_struct", "struct", "xxhash64", @@ -305,6 +310,13 @@ pub(super) fn rows() -> Vec { "col: ColumnOrName, errMsg: Column | str = None", ), Row::new("raise_error", "errMsg: Column | str"), + Row::new("create_map", "*cols: ColumnOrName").to("map"), + Row::new("map_contains_key", "col: ColumnOrName, value: Any"), + Row::new("map_from_arrays", "col1: ColumnOrName, col2: ColumnOrName"), + Row::new( + "str_to_map", + "text: ColumnOrName, pairDelim: ColumnOrName = None, keyValueDelim: ColumnOrName = None", + ), Row::new("bitwise_not", C).to("~"), Row::new("mean", C).to("avg"), Row::new("btrim", "str: ColumnOrName, trim: ColumnOrName = None"), diff --git a/crates/krishiv-functions/src/registry/defs.rs b/crates/krishiv-functions/src/registry/defs.rs index 080e919c0..17b01e308 100644 --- a/crates/krishiv-functions/src/registry/defs.rs +++ b/crates/krishiv-functions/src/registry/defs.rs @@ -843,6 +843,7 @@ pub(super) fn specs() -> Vec { out.extend(aggregates()); out.extend(windows()); out.extend(super::conditional::specs()); + out.extend(super::map::specs()); out.extend(super::math::specs()); out.extend(super::hashing::specs()); out.extend(super::bitwise::specs()); diff --git a/crates/krishiv-functions/src/registry/map.rs b/crates/krishiv-functions/src/registry/map.rs new file mode 100644 index 000000000..e5530319c --- /dev/null +++ b/crates/krishiv-functions/src/registry/map.rs @@ -0,0 +1,332 @@ +// SPDX-License-Identifier: Apache-2.0 +//! The map functions' analysis signatures: `map`, `map_concat`, +//! `map_contains_key`, `map_keys`, `map_values`, `map_entries`, +//! `map_from_arrays`, `map_from_entries` and `str_to_map`. +//! +//! Typing follows Spark 4.2 (`CreateMap`, `MapConcat`, `MapContainsKey`, +//! `MapKeys`, `MapValues`, `MapEntries`, `MapFromArrays`, `MapFromEntries`, +//! `StringToMap` at the v4.2.0 tag): the implicit casts of +//! `TypeCoercionHelper` (keys and values of `map` meet separately, +//! `map_concat` needs every map and, with ANSI, the same type) and the +//! result types, checked against the function-matrix fixtures. Coercion +//! lives in the analyzer (`Inputs::Map`, `Inputs::MapConcat`, +//! `Inputs::MapContainsKey`); the rules below read the cast types. + +use krishiv_common::error::{ + DatatypeMismatchInvalidMapKeyType, DatatypeMismatchMapFunctionDiffTypes, + DatatypeMismatchNullType, DatatypeMismatchUnexpectedInputType, KrishivError, +}; +use krishiv_types::{ArrayType, DataType, MapType, StructField, StructType}; + +use super::defs::{Spec, scalar}; +use crate::signature::{ArgType, CallTypes, InputType, Inputs}; + +/// The whole call as Spark quotes it (`"map_contains_key(map(1, a), 1)"`). +fn call_sql(name: &str, c: &CallTypes<'_>) -> String { + let args: Vec = (0..c.args().len()) + .map(|i| c.sql(i).unwrap_or_default()) + .collect(); + format!("\"{name}({})\"", args.join(", ")) +} + +/// The map type of argument `i`, when it is one. +fn map_at(c: &CallTypes<'_>, i: usize) -> Option { + match c.data_type(i) { + Some(DataType::Map(m)) => Some((**m).clone()), + _ => None, + } +} + +/// Whether the type contains a map (Spark's `checkForMapKeyType`, without +/// the variant case: Krishiv has no variant type). +fn contains_map(t: &DataType) -> bool { + match t { + DataType::Map(_) => true, + DataType::Array(a) => contains_map(a.element_type()), + DataType::Struct(s) => s.fields().iter().any(|f| contains_map(f.data_type())), + _ => false, + } +} + +/// `map(k1, v1, ...)`: the common key and value types (the analyzer met +/// them), `INVALID_MAP_KEY_TYPE` for a key holding a map. Never null. +fn map_result(c: &CallTypes<'_>) -> Result { + let key = c + .args() + .iter() + .step_by(2) + .filter_map(|a| a.data_type.clone()) + .next() + .unwrap_or(DataType::Null); + let value = c + .args() + .iter() + .skip(1) + .step_by(2) + .filter_map(|a| a.data_type.clone()) + .next() + .unwrap_or(DataType::Null); + let value_nullable = c.args().iter().skip(1).step_by(2).any(|a| a.nullable); + if contains_map(&key) { + return Err(DatatypeMismatchInvalidMapKeyType { + sql_expr: call_sql("map", c), + key_type: format!("\"{}\"", key.sql()), + } + .into()); + } + Ok(ArgType::new( + MapType::new(key, value, value_nullable).into(), + false, + )) +} + +/// `map_concat(m1, ...)`: the merged map type (the analyzer met the maps, +/// or they share it); `INVALID_MAP_KEY_TYPE` for a key holding a map. +/// Null when any argument may be. +fn map_concat_result(c: &CallTypes<'_>) -> Result { + let mut merged: Option = None; + for a in c.args() { + let Some(t) = a.data_type.clone() else { + continue; + }; + merged = Some(match merged { + None => t, + Some(m) => m.union_like_merge(&t), + }); + } + let merged = merged.unwrap_or(MapType::new(DataType::String, DataType::String, true).into()); + if let DataType::Map(m) = &merged + && contains_map(m.key_type()) + { + return Err(DatatypeMismatchInvalidMapKeyType { + sql_expr: call_sql("map_concat", c), + key_type: format!("\"{}\"", m.key_type().sql()), + } + .into()); + } + Ok(ArgType::new(merged, c.any_nullable())) +} + +/// `map_contains_key(map, key)`: `NULL_TYPE` for an untyped null key; +/// `MAP_FUNCTION_DIFF_TYPES` unless the (cast) key shares the map's key +/// type. Always null: Spark evaluates it as `array_contains`, whose array +/// (`map_keys`) may hold nulls. +fn map_contains_key_result(c: &CallTypes<'_>) -> Result { + let sql_expr = call_sql("map_contains_key", c); + if c.data_type(1).is_none() { + return Err(DatatypeMismatchNullType { + sql_expr, + function_name: "`map_contains_key`".to_owned(), + } + .into()); + } + let same = match (c.data_type(0), c.data_type(1)) { + (Some(DataType::Map(m)), Some(k)) => m.key_type().equals_ignore_nullability(k), + _ => false, + }; + if !same { + return Err(DatatypeMismatchMapFunctionDiffTypes { + sql_expr, + function_name: "`map_contains_key`".to_owned(), + data_type: "\"MAP\"".to_owned(), + left_type: quoted(c.data_type(0)), + right_type: quoted(c.data_type(1)), + } + .into()); + } + Ok(ArgType::new(DataType::Boolean, true)) +} + +fn quoted(t: Option<&DataType>) -> String { + format!("\"{}\"", t.map_or_else(|| "VOID".to_owned(), DataType::sql)) +} + +/// `map_keys`, `map_values`, `map_entries`: the projection of the (cast) +/// map argument. The argument is always a map here (the analyzer refused +/// anything else); anything else is the same `UNEXPECTED_INPUT_TYPE`. +fn projection( + c: &CallTypes<'_>, + name: &str, + pick: impl FnOnce(&MapType) -> DataType, +) -> Result { + let Some(m) = map_at(c, 0) else { + return Err(DatatypeMismatchUnexpectedInputType { + sql_expr: call_sql(name, c), + param_index: "first".to_owned(), + required_type: "\"MAP\"".to_owned(), + input_sql: format!("\"{}\"", c.sql(0).unwrap_or_default()), + input_type: quoted(c.data_type(0)), + } + .into()); + }; + let nullable = c.args().first().is_some_and(|a| a.nullable); + Ok(ArgType::new(pick(&m), nullable)) +} + +fn map_keys_result(c: &CallTypes<'_>) -> Result { + projection(c, "map_keys", |m| { + ArrayType::new(m.key_type().clone(), true).into() + }) +} + +fn map_values_result(c: &CallTypes<'_>) -> Result { + projection(c, "map_values", |m| { + ArrayType::new(m.value_type().clone(), true).into() + }) +} + +fn map_entries_result(c: &CallTypes<'_>) -> Result { + projection(c, "map_entries", |m| { + ArrayType::new( + StructType::new([ + StructField::new("key", m.key_type().clone(), false), + StructField::new("value", m.value_type().clone(), m.value_contains_null()), + ]) + .into(), + false, + ) + .into() + }) +} + +/// `map_from_arrays(keys, values)`: the map of the (cast) array element +/// types. `INVALID_MAP_KEY_TYPE` for a key holding a map. Null when any +/// argument may be. +fn map_from_arrays_result(c: &CallTypes<'_>) -> Result { + let (keys, values) = (array_at(c, 0), array_at(c, 1)); + let (kt, vt, contains_null) = match (keys, values) { + (Some(k), Some(v)) => ( + k.element_type().clone(), + v.element_type().clone(), + v.contains_null(), + ), + _ => (DataType::Null, DataType::Null, true), + }; + if contains_map(&kt) { + return Err(DatatypeMismatchInvalidMapKeyType { + sql_expr: call_sql("map_from_arrays", c), + key_type: format!("\"{}\"", kt.sql()), + } + .into()); + } + Ok(ArgType::new( + MapType::new(kt, vt, contains_null).into(), + c.any_nullable(), + )) +} + +fn array_at(c: &CallTypes<'_>, i: usize) -> Option { + match c.data_type(i) { + Some(DataType::Array(a)) => Some((**a).clone()), + _ => None, + } +} + +/// `map_from_entries(entries)`: the map of the entry struct's fields; the +/// argument must be an array of two-field structs +/// (`UNEXPECTED_INPUT_TYPE` otherwise). `INVALID_MAP_KEY_TYPE` for a key +/// holding a map. Null when the array may be null or hold nulls. +fn map_from_entries_result(c: &CallTypes<'_>) -> Result { + let entry = match c.data_type(0) { + Some(DataType::Array(a)) + if matches!( + a.element_type(), + DataType::Struct(s) if s.fields().len() == 2 + ) => + { + std::sync::Arc::clone(a) + } + _ => { + return Err(DatatypeMismatchUnexpectedInputType { + sql_expr: call_sql("map_from_entries", c), + param_index: "first".to_owned(), + required_type: "\"ARRAY\" of pair \"STRUCT\"".to_owned(), + input_sql: format!("\"{}\"", c.sql(0).unwrap_or_default()), + input_type: quoted(c.data_type(0)), + } + .into()); + } + }; + let DataType::Struct(fields) = entry.element_type() else { + return Err(DatatypeMismatchUnexpectedInputType { + sql_expr: call_sql("map_from_entries", c), + param_index: "first".to_owned(), + required_type: "\"ARRAY\" of pair \"STRUCT\"".to_owned(), + input_sql: format!("\"{}\"", c.sql(0).unwrap_or_default()), + input_type: quoted(c.data_type(0)), + } + .into()); + }; + let (key, value) = (&fields.fields()[0], &fields.fields()[1]); + if contains_map(key.data_type()) { + return Err(DatatypeMismatchInvalidMapKeyType { + sql_expr: call_sql("map_from_entries", c), + key_type: format!("\"{}\"", key.data_type().sql()), + } + .into()); + } + let nullable = c.args().first().is_some_and(|a| a.nullable) || entry.contains_null(); + Ok(ArgType::new( + MapType::new( + key.data_type().clone(), + value.data_type().clone(), + value.nullable(), + ) + .into(), + nullable, + )) +} + +/// `str_to_map(text[, pairDelim[, keyValueDelim]])`: `map`. +/// Null when any argument may be. +fn str_to_map_result(c: &CallTypes<'_>) -> Result { + Ok(ArgType::new( + MapType::new(DataType::String, DataType::String, true).into(), + c.any_nullable(), + )) +} + +pub(super) fn specs() -> Vec { + let mut out = scalar(&["map"], &Inputs::Map, map_result); + out.extend(scalar( + &["map_concat"], + &Inputs::MapConcat, + map_concat_result, + )); + out.extend(scalar( + &["map_contains_key"], + &Inputs::MapContainsKey, + map_contains_key_result, + )); + out.extend(scalar( + &["map_keys"], + &Inputs::Expects(vec![InputType::Map]), + map_keys_result, + )); + out.extend(scalar( + &["map_values"], + &Inputs::Expects(vec![InputType::Map]), + map_values_result, + )); + out.extend(scalar( + &["map_entries"], + &Inputs::Expects(vec![InputType::Map]), + map_entries_result, + )); + out.extend(scalar( + &["map_from_arrays"], + &Inputs::Expects(vec![InputType::Array, InputType::Array]), + map_from_arrays_result, + )); + out.extend(scalar( + &["map_from_entries"], + &Inputs::Any, + map_from_entries_result, + )); + out.extend(scalar( + &["str_to_map"], + &Inputs::Expects(vec![InputType::Strict(DataType::String)]), + str_to_map_result, + )); + out +} diff --git a/crates/krishiv-functions/src/registry/mod.rs b/crates/krishiv-functions/src/registry/mod.rs index 971415d69..c536ae500 100644 --- a/crates/krishiv-functions/src/registry/mod.rs +++ b/crates/krishiv-functions/src/registry/mod.rs @@ -20,6 +20,7 @@ mod csv; mod defs; mod hashing; mod hof; +mod map; mod math; mod misc; mod number; diff --git a/crates/krishiv-functions/src/registry/tests.rs b/crates/krishiv-functions/src/registry/tests.rs index 64178fb67..117759b65 100644 --- a/crates/krishiv-functions/src/registry/tests.rs +++ b/crates/krishiv-functions/src/registry/tests.rs @@ -1845,6 +1845,187 @@ fn regex_signatures() { assert_eq!(r, ArgType::new(DataType::Integer, true)); } +#[test] +fn map_signatures() { + use krishiv_types::{ArrayType, MapType, StructField, StructType}; + let (i, s) = (ty(DataType::Integer), ty(DataType::String)); + let map = + |k: DataType, v: DataType, vcn: bool| ArgType::new(MapType::new(k, v, vcn).into(), false); + assert_eq!(def("map").inputs, Inputs::Map); + assert_eq!(def("map_concat").inputs, Inputs::MapConcat); + assert_eq!(def("map_contains_key").inputs, Inputs::MapContainsKey); + // `map(k, v)`: the key and value types, never null; values may hold + // null when any value argument may. + assert_eq!( + result("map", &[i.clone(), s.clone(), i.clone(), s.clone()], &[]).unwrap(), + map(DataType::Integer, DataType::String, false) + ); + assert_eq!( + result( + "map", + &[i.clone(), ArgType::new(DataType::String, true)], + &[] + ) + .unwrap(), + ArgType::new( + MapType::new(DataType::Integer, DataType::String, true).into(), + false + ) + ); + // A key holding a map is `INVALID_MAP_KEY_TYPE`. + let nested: DataType = MapType::new(DataType::String, DataType::Integer, true).into(); + let e = result("map", &[ty(nested.clone()), s.clone()], &[]).unwrap_err(); + assert_eq!( + e.error_class(), + ErrorClass::DatatypeMismatchInvalidMapKeyType + ); + for name in ["map_concat", "map_from_arrays"] { + let key = if name == "map_concat" { + MapType::new(nested.clone(), DataType::String, true).into() + } else { + ArrayType::new(nested.clone(), false).into() + }; + let value = if name == "map_concat" { + nested.clone() + } else { + ArrayType::new(DataType::String, false).into() + }; + let e = result(name, &[ty(key), ty(value)], &[]).unwrap_err(); + assert_eq!( + e.error_class(), + ErrorClass::DatatypeMismatchInvalidMapKeyType, + "{name}" + ); + } + // `map_concat(m)`: the merged map, null when any argument may be. + assert_eq!( + result( + "map_concat", + &[ + ArgType::new( + MapType::new(DataType::Integer, DataType::String, false).into(), + true + ), + ArgType::new( + MapType::new(DataType::Integer, DataType::String, true).into(), + false + ), + ], + &[] + ) + .unwrap(), + ArgType::new( + MapType::new(DataType::Integer, DataType::String, true).into(), + true + ) + ); + // `map_contains_key(map, key)`: a nullable boolean, `MAP_FUNCTION_DIFF_TYPES` + // for a key of another type, `NULL_TYPE` for an untyped null key. + assert_eq!( + result( + "map_contains_key", + &[map(DataType::Integer, DataType::String, false), i.clone()], + &[] + ) + .unwrap(), + ArgType::new(DataType::Boolean, true) + ); + let e = result( + "map_contains_key", + &[map(DataType::Integer, DataType::String, false), s.clone()], + &[], + ) + .unwrap_err(); + assert_eq!( + e.error_class(), + ErrorClass::DatatypeMismatchMapFunctionDiffTypes + ); + let e = result( + "map_contains_key", + &[map(DataType::Integer, DataType::String, false), null_ty()], + &[], + ) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::DatatypeMismatchNullType); + // `map_keys`, `map_values`, `map_entries`: the projections. + let m = ArgType::new( + MapType::new(DataType::Integer, DataType::String, true).into(), + true, + ); + assert_eq!( + result("map_keys", std::slice::from_ref(&m), &[]).unwrap(), + ArgType::new(ArrayType::new(DataType::Integer, true).into(), true) + ); + assert_eq!( + result("map_values", std::slice::from_ref(&m), &[]).unwrap(), + ArgType::new(ArrayType::new(DataType::String, true).into(), true) + ); + assert_eq!( + result("map_entries", std::slice::from_ref(&m), &[]).unwrap(), + ArgType::new( + ArrayType::new( + StructType::new([ + StructField::new("key", DataType::Integer, false), + StructField::new("value", DataType::String, true), + ]) + .into(), + false + ) + .into(), + true + ) + ); + let e = result("map_keys", std::slice::from_ref(&i), &[]).unwrap_err(); + assert_eq!( + e.error_class(), + ErrorClass::DatatypeMismatchUnexpectedInputType + ); + // `map_from_arrays(keys, values)`: the map of the element types. + assert_eq!( + result( + "map_from_arrays", + &[ + ty(ArrayType::new(DataType::Integer, false).into()), + ty(ArrayType::new(DataType::String, false).into()), + ], + &[] + ) + .unwrap(), + map(DataType::Integer, DataType::String, false) + ); + // `map_from_entries`: the map of the struct fields; anything else is + // `UNEXPECTED_INPUT_TYPE`. + let pair = ArrayType::new( + StructType::new([ + StructField::new("key", DataType::Integer, true), + StructField::new("value", DataType::String, true), + ]) + .into(), + true, + ) + .into(); + assert_eq!( + result("map_from_entries", &[ty(pair)], &[]).unwrap(), + ArgType::new( + MapType::new(DataType::Integer, DataType::String, true).into(), + true + ) + ); + let e = result("map_from_entries", std::slice::from_ref(&i), &[]).unwrap_err(); + assert_eq!( + e.error_class(), + ErrorClass::DatatypeMismatchUnexpectedInputType + ); + // `str_to_map(text)`: `map`. + assert_eq!( + result("str_to_map", std::slice::from_ref(&s), &[]).unwrap(), + ArgType::new( + MapType::new(DataType::String, DataType::String, true).into(), + false + ) + ); +} + #[test] fn hof_signatures() { use DataType::{Array, Boolean, Integer}; diff --git a/crates/krishiv-functions/src/scalar/map.rs b/crates/krishiv-functions/src/scalar/map.rs new file mode 100644 index 000000000..7ba4f3786 --- /dev/null +++ b/crates/krishiv-functions/src/scalar/map.rs @@ -0,0 +1,383 @@ +// SPDX-License-Identifier: Apache-2.0 +//! Map functions (P2-T029 kernels): `map`, `map_concat`, +//! `map_contains_key`, `map_keys`, `map_values`, `map_entries`, +//! `map_from_arrays`, `map_from_entries` and `str_to_map`. +//! +//! Arguments arrive after the analyzer's implicit casts, so keys and values +//! already share their Spark types (the binding only maps Arrow carriers to +//! the canonical ones) and delimiters are strings. The kernels build the +//! maps; this family computes the output Arrow types from the Spark types +//! (exactly the analyzer's, via [`krishiv_types`]) and reads the session's +//! map-key dedup policy from [`BindOptions`]. + +use std::collections::HashMap; +use std::sync::Arc; + +use arrow_array::{Array, ArrayRef, StringArray}; +use arrow_schema::{DataType, Field, FieldRef}; +use krishiv_common::error::KrishivError; +use krishiv_kernels::map::{self as kh, DedupPolicy}; +use krishiv_types::{DataType as SparkType, MapType}; + +use super::args::{Inputs, internal, is_string, to_utf8}; +use super::regex::Splitter; +use super::{BindArg, BindOptions, Binding, FamilyResult, bad_types, listed}; + +/// Every name this family binds. +pub(super) const NAMES: &[&str] = &[ + "map", + "map_concat", + "map_contains_key", + "map_entries", + "map_from_arrays", + "map_from_entries", + "map_keys", + "map_values", + "str_to_map", +]; + +/// The Spark type of an Arrow carrier (what the analyzer typed). +fn spark_type(name: &str, args: &[BindArg], t: &DataType) -> Result { + SparkType::from_arrow(t).map_err(|_| bad_types(name, args)) +} + +/// The output `entries` field of a map of `key`/`value` Spark types: the +/// analyzer's field, exactly. +fn entries_field(key: &SparkType, value: &SparkType, value_nullable: bool) -> FieldRef { + let entries = DataType::Struct( + vec![ + key.to_arrow_field("key", false), + value.to_arrow_field("value", value_nullable), + ] + .into(), + ); + Arc::new(Field::new("entries", entries, false)) +} + +/// The output map type of `key`/`value` Spark types. +fn map_type(key: &SparkType, value: &SparkType, value_nullable: bool) -> DataType { + DataType::Map(entries_field(key, value, value_nullable), false) +} + +/// The output list type of `element` under the field `name`. +fn list_type(element: &Field, nullable: bool) -> DataType { + DataType::List(Arc::new(Field::new( + "element", + element.data_type().clone(), + nullable, + ))) +} + +/// Binds the map function `name`. +pub(super) fn bind(name: &str, args: &[BindArg], opts: &BindOptions) -> FamilyResult { + let listed = listed(NAMES, name)?; + let policy: DedupPolicy = opts.map_key_dedup_policy; + let types: Vec = args.iter().map(BindArg::data_type).collect(); + let binding = match (listed, types.as_slice()) { + ("map", _) if args.len().is_multiple_of(2) => map_bind(args, &types, policy), + ("map_concat", []) => map_concat_bind(args, &[], policy), + ("map_concat", _) if !args.is_empty() => map_concat_bind(args, &types, policy), + ("map_contains_key", [m, k]) if matches!(m, DataType::Map(_, _)) && kh::supports_key(k) => { + Ok(Binding::new(DataType::Boolean, move |x: &Inputs<'_>| { + let (map, key) = (x.column(0)?, x.column(1)?); + Ok(Arc::new(kh::contains_key(&map, &key)?) as ArrayRef) + })) + } + ("map_keys" | "map_values" | "map_entries", [m @ DataType::Map(entries, _)]) + if kh::supports_value(m) => + { + projection_bind(listed, entries) + } + ("map_from_arrays", [k, v]) + if matches!(k, DataType::List(_) | DataType::LargeList(_)) + && matches!(v, DataType::List(_) | DataType::LargeList(_)) + && kh::supports_key(k) + && kh::supports_value(v) => + { + from_arrays_bind(args, k, v, policy) + } + ("map_from_entries", [e]) if kh::supports_value(e) => from_entries_bind(args, e, policy), + ("str_to_map", [t] | [t, _] | [t, _, _]) if is_string(t) => str_to_map_bind(args, policy), + _ => Err(bad_types(listed, args)), + }; + Some((listed, binding)) +} + +/// `map(k1, v1, ...)`: one entry per key/value column pair per row. +fn map_bind( + args: &[BindArg], + types: &[DataType], + policy: DedupPolicy, +) -> Result { + let listed = "map"; + let mut key = SparkType::Null; + let mut value = SparkType::Null; + let mut first = true; + for (k, v) in types.iter().step_by(2).zip(types.iter().skip(1).step_by(2)) { + if !kh::supports_key(k) || !kh::supports_value(v) { + return Err(bad_types(listed, args)); + } + let (ks, vs) = (spark_type(listed, args, k)?, spark_type(listed, args, v)?); + if first { + key = ks; + value = vs; + first = false; + } else if ks != key || vs != value { + return Err(bad_types(listed, args)); + } + } + let value_nullable = args.iter().skip(1).step_by(2).any(BindArg::nullable); + let out = map_type(&key, &value, value_nullable); + let entries = map_entries_of(&out).ok_or_else(|| bad_types(listed, args))?; + let n = args.len(); + Ok(Binding::new(out, move |x: &Inputs<'_>| { + let mut keys = Vec::with_capacity(n / 2); + let mut values = Vec::with_capacity(n / 2); + for i in (0..n).step_by(2) { + keys.push(x.column(i)?); + values.push(x.column(i + 1)?); + } + Ok(Arc::new(kh::create_map(&keys, &values, x.rows(), &entries, policy)?) as ArrayRef) + })) +} + +/// `map_concat(m1, ...)`: the entries of every map per row, in order. +fn map_concat_bind( + args: &[BindArg], + types: &[DataType], + policy: DedupPolicy, +) -> Result { + let listed = "map_concat"; + let mut merged: Option = None; + for t in types { + if !matches!(t, DataType::Map(_, _)) || !kh::supports_value(t) { + return Err(bad_types(listed, args)); + } + let s = spark_type(listed, args, t)?; + merged = Some(match merged { + None => s, + Some(m) => m.union_like_merge(&s), + }); + } + let merged = merged.unwrap_or(SparkType::Map(Arc::new(MapType::new( + SparkType::String, + SparkType::String, + true, + )))); + let out = merged.to_arrow(); + let entries = map_entries_of(&out).ok_or_else(|| bad_types(listed, args))?; + let n = args.len(); + Ok(Binding::new(out, move |x: &Inputs<'_>| { + let maps = (0..n).map(|i| x.column(i)).collect::, _>>()?; + Ok(Arc::new(kh::concat(&maps, x.rows(), &entries, policy)?) as ArrayRef) + })) +} + +/// `map_keys`, `map_values`, `map_entries`: the projection of the map. +fn projection_bind(listed: &'static str, entries: &FieldRef) -> Result { + let out = match listed { + "map_keys" => { + let key = spark_map_key(entries)?; + list_type(&key.to_arrow_field("element", true), true) + } + "map_values" => { + let value = spark_map_value(entries)?; + list_type(&value.to_arrow_field("element", true), true) + } + _ => DataType::List(Arc::new(Field::new( + "element", + DataType::Struct( + vec![ + spark_map_key(entries)?.to_arrow_field("key", false), + spark_map_value(entries)?.to_arrow_field("value", map_value_nullable(entries)?), + ] + .into(), + ), + false, + ))), + }; + let element = field_of(&out)?; + Ok(Binding::new(out, move |x: &Inputs<'_>| { + let map = x.column(0)?; + Ok(match listed { + "map_keys" => kh::keys(&map, &element)?, + "map_values" => kh::values(&map, &element)?, + _ => kh::entries(&map, &element)?, + }) + })) +} + +/// `map_from_arrays(keys, values)`: row `r` maps the `r`-th key slice to +/// the `r`-th value slice. +fn from_arrays_bind( + args: &[BindArg], + k: &DataType, + v: &DataType, + policy: DedupPolicy, +) -> Result { + let listed = "map_from_arrays"; + let (ks, vs) = (spark_type(listed, args, k)?, spark_type(listed, args, v)?); + let (SparkType::Array(kt), SparkType::Array(vt)) = (ks, vs) else { + return Err(bad_types(listed, args)); + }; + let out = map_type(kt.element_type(), vt.element_type(), vt.contains_null()); + let entries = map_entries_of(&out).ok_or_else(|| bad_types(listed, args))?; + Ok(Binding::new(out, move |x: &Inputs<'_>| { + let (keys, values) = (x.column(0)?, x.column(1)?); + Ok(Arc::new(kh::from_arrays(&keys, &values, x.rows(), &entries, policy)?) as ArrayRef) + })) +} + +/// `map_from_entries(entries)`: the entry structs' fields become the map's +/// key and value. +fn from_entries_bind( + args: &[BindArg], + e: &DataType, + policy: DedupPolicy, +) -> Result { + let entries = entries_field_of("map_from_entries", args, e)?; + let out = DataType::Map(Arc::clone(&entries), false); + Ok(Binding::new(out, move |x: &Inputs<'_>| { + let array = x.column(0)?; + Ok(Arc::new(kh::from_entries(&array, x.rows(), &entries, policy)?) as ArrayRef) + })) +} + +/// `str_to_map(text[, pairDelim[, keyValueDelim]])`: splits every row's +/// text and assembles the pairs. +fn str_to_map_bind(args: &[BindArg], policy: DedupPolicy) -> Result { + let out = map_type(&SparkType::String, &SparkType::String, true); + let entries = map_entries_of(&out).ok_or_else(|| bad_types("str_to_map", args))?; + let n = args.len(); + Ok(Binding::new(out, move |x: &Inputs<'_>| { + str_to_map(x, n, &entries, policy) + })) +} + +/// The `entries` field of an output map type. +fn map_entries_of(out: &DataType) -> Option { + match out { + DataType::Map(e, _) => Some(Arc::clone(e)), + _ => None, + } +} + +/// The key/value Spark type of a map entries field. +fn spark_map_key(entries: &FieldRef) -> Result { + match entries.data_type() { + DataType::Struct(fs) if fs.len() == 2 => { + SparkType::from_arrow(fs[0].data_type()).map_err(|e| internal(e.to_string())) + } + t => Err(internal(format!("map entries of type {t}"))), + } +} + +fn spark_map_value(entries: &FieldRef) -> Result { + match entries.data_type() { + DataType::Struct(fs) if fs.len() == 2 => { + SparkType::from_arrow(fs[1].data_type()).map_err(|e| internal(e.to_string())) + } + t => Err(internal(format!("map entries of type {t}"))), + } +} + +fn map_value_nullable(entries: &FieldRef) -> Result { + match entries.data_type() { + DataType::Struct(fs) if fs.len() == 2 => Ok(fs[1].is_nullable()), + t => Err(internal(format!("map entries of type {t}"))), + } +} + +fn field_of(t: &DataType) -> Result { + match t { + DataType::List(f) => Ok(Arc::clone(f)), + t => Err(internal(format!("a list type {t}"))), + } +} + +/// The `entries` field of the array-of-structs argument of +/// `map_from_entries`: the struct's fields become the map's key and value. +fn entries_field_of(name: &str, args: &[BindArg], t: &DataType) -> Result { + let bad = || bad_types(name, args); + let SparkType::Array(a) = spark_type(name, args, t)? else { + return Err(bad()); + }; + let SparkType::Struct(s) = a.element_type().clone() else { + return Err(bad()); + }; + if s.fields().len() != 2 { + return Err(bad()); + } + let (key, value) = (&s.fields()[0], &s.fields()[1]); + Ok(entries_field( + key.data_type(), + value.data_type(), + value.nullable(), + )) +} + +/// `str_to_map(text[, pairDelim[, keyValueDelim]])` over one batch: splits +/// every row's text and assembles the pairs. +fn str_to_map( + x: &Inputs<'_>, + n: usize, + entries: &FieldRef, + policy: DedupPolicy, +) -> Result { + let rows = x.rows(); + let text = to_utf8(x.column(0)?.as_ref())?; + let pair_delim = if n > 1 { + Some(to_utf8(x.column(1)?.as_ref())?) + } else { + None + }; + let kv_delim = if n > 2 { + Some(to_utf8(x.column(2)?.as_ref())?) + } else { + None + }; + fn delim_at(col: &arrow_array::StringArray, r: usize) -> Option<&str> { + col.is_valid(r).then(|| col.value(r)) + } + let mut pair_splitters: HashMap = HashMap::new(); + let mut kv_splitters: HashMap = HashMap::new(); + // The splitter for `d`, compiled once per distinct delimiter. + fn splitter<'a>( + cache: &'a mut HashMap, + d: &str, + ) -> Result<&'a Splitter, KrishivError> { + if !cache.contains_key(d) { + cache.insert(d.to_owned(), Splitter::new(d)?); + } + cache + .get(d) + .ok_or_else(|| internal("a splitter just compiled".to_owned())) + } + let mut keys: Vec> = Vec::new(); + let mut values: Vec> = Vec::new(); + let mut row_of: Vec = Vec::new(); + for r in 0..rows { + let Some(t) = text.is_valid(r).then(|| text.value(r)) else { + continue; + }; + let pair = pair_delim.as_ref().map_or(Some(","), |c| delim_at(c, r)); + let kv = kv_delim.as_ref().map_or(Some(":"), |c| delim_at(c, r)); + let (Some(pair), Some(kv)) = (pair, kv) else { + continue; + }; + let pair_split = splitter(&mut pair_splitters, pair)?; + let kv_split = splitter(&mut kv_splitters, kv)?; + for piece in pair_split.split(t, -1)? { + let kvp = kv_split.split(&piece, 2)?; + let mut kvp = kvp.into_iter(); + keys.push(kvp.next()); + values.push(kvp.next()); + row_of.push(r); + } + } + let keys = Arc::new(StringArray::from(keys)) as ArrayRef; + let values = Arc::new(StringArray::from(values)) as ArrayRef; + Ok(Arc::new(kh::from_pairs( + &keys, &values, &row_of, rows, entries, policy, + )?) as ArrayRef) +} diff --git a/crates/krishiv-functions/src/scalar/mod.rs b/crates/krishiv-functions/src/scalar/mod.rs index cee46c6a7..b6ee458fb 100644 --- a/crates/krishiv-functions/src/scalar/mod.rs +++ b/crates/krishiv-functions/src/scalar/mod.rs @@ -31,6 +31,7 @@ mod chars; mod codec; mod datetime; mod hash; +mod map; mod math; mod misc; mod number; @@ -53,6 +54,7 @@ use arrow_schema::DataType; use krishiv_common::error::KrishivError; use krishiv_kernels::KernelCtx; use krishiv_kernels::cast::{FixedOffset, TimeZoneRules}; +use krishiv_kernels::map::DedupPolicy; pub use args::Arg; use args::{Inputs, broadcast, internal, unsupported}; @@ -123,6 +125,9 @@ pub struct BindOptions { /// `spark.sql.decimalOperations.allowPrecisionLoss`: the result types of /// decimal arithmetic (`pmod`, `try_add`, ...). pub decimal_precision_loss: bool, + /// `spark.sql.mapKeyDedupPolicy`: how the map functions resolve + /// duplicate keys. + pub map_key_dedup_policy: DedupPolicy, /// The session's user (`current_user()`). pub user: Arc, /// Counts the unseeded random binds of one plan instantiation, in @@ -143,6 +148,7 @@ impl BindOptions { time_zone: Arc::new(FixedOffset(0)), query_start_micros: 0, decimal_precision_loss: true, + map_key_dedup_policy: DedupPolicy::Exception, user: Arc::from("unknown"), seed_salt: Arc::new(AtomicU64::new(0)), } @@ -176,6 +182,13 @@ impl BindOptions { self } + /// With `spark.sql.mapKeyDedupPolicy = policy`. + #[must_use] + pub const fn with_map_key_dedup_policy(mut self, policy: DedupPolicy) -> Self { + self.map_key_dedup_policy = policy; + self + } + /// With this session user (`current_user()`, `user()`, `session_user()`). #[must_use] pub fn with_user(mut self, user: impl Into>) -> Self { @@ -390,7 +403,7 @@ type FamilyResult = Option<(&'static str, Result)>; type Binder = fn(&str, &[BindArg], &BindOptions) -> FamilyResult; /// The families (their names and binder), in lookup order. -const FAMILIES: [(&[&str], Binder); 17] = [ +const FAMILIES: [(&[&str], Binder); 18] = [ (array::NAMES, array::bind), (string::NAMES, string::bind), (datetime::NAMES, datetime::bind), @@ -398,6 +411,7 @@ const FAMILIES: [(&[&str], Binder); 17] = [ (regex::NAMES, regex::bind), (arith::NAMES, arith::bind), (hash::NAMES, hash::bind), + (map::NAMES, map::bind), (session::NAMES, session::bind), (bitwise::NAMES, bitwise::bind), (predicate::NAMES, predicate::bind), @@ -424,7 +438,8 @@ pub fn scalar_names() -> Vec<&'static str> { /// Whether the result of the scalar function `name` depends only on its /// arguments and `spark.sql.ansi.enabled`: the string (with its character and -/// encoding families), math, arithmetic and struct families. The datetime, session and +/// encoding families), math, arithmetic, struct and map families (the map family also reads +/// `spark.sql.mapKeyDedupPolicy`). The datetime, session and /// hash families read the session time zone, the user or the query start, so a /// caller that evaluates a call before execution (constant folding) must not /// evaluate those. @@ -437,6 +452,7 @@ pub fn is_argument_pure(name: &str) -> bool { codec::NAMES, math::NAMES, arith::NAMES, + map::NAMES, r#struct::NAMES, ] .iter() diff --git a/crates/krishiv-functions/src/scalar/regex.rs b/crates/krishiv-functions/src/scalar/regex.rs index f721708fc..ab2515435 100644 --- a/crates/krishiv-functions/src/scalar/regex.rs +++ b/crates/krishiv-functions/src/scalar/regex.rs @@ -527,6 +527,30 @@ fn split_pieces( split_pattern(compiled, s, limit) } +/// A Java regex delimiter split for `str_to_map`: the pattern compiles +/// once, then splits every row's text with Spark's limit semantics (as +/// [`split_pieces`]). An invalid pattern is +/// `INVALID_PARAMETER_VALUE.PATTERN`, as for `split`. +pub(super) struct Splitter { + pattern: String, + compiled: Compiled, +} + +impl Splitter { + /// Compiles the Java regex `pattern` for [`Self::split`]. + pub(super) fn new(pattern: &str) -> Result { + Ok(Self { + pattern: pattern.to_owned(), + compiled: Compiled::new(pattern, "`str_to_map`")?, + }) + } + + /// Splits `s` with Spark's limit semantics. + pub(super) fn split(&self, s: &str, limit: i32) -> Result, KrishivError> { + split_pieces(s, &self.pattern, &self.compiled, limit) + } +} + /// Spark `split(str, pattern[, limit])` over a column: one row per input, /// NULL in for NULL out. `limit` holds one entry per row (`None` is NULL). /// The pattern compiles once per call. diff --git a/crates/krishiv-functions/src/scalar/tests/map.rs b/crates/krishiv-functions/src/scalar/tests/map.rs new file mode 100644 index 000000000..779197a97 --- /dev/null +++ b/crates/krishiv-functions/src/scalar/tests/map.rs @@ -0,0 +1,545 @@ +// SPDX-License-Identifier: Apache-2.0 +//! The map family's bindings: row maps, projections, entry builders and +//! `str_to_map` over columns and literals. + +use std::sync::Arc; + +use arrow_array::builder::{ArrayBuilder, Int32Builder, ListBuilder, StringBuilder, StructBuilder}; +use arrow_array::cast::AsArray; +use arrow_array::{Array, ArrayRef, MapArray, StructArray}; +use arrow_buffer::NullBuffer; +use arrow_schema::{DataType, Field}; +use krishiv_common::error::ErrorClass; +use krishiv_kernels::map::DedupPolicy; + +use super::super::{BindArg, BindOptions, bind_scalar}; +use super::{bind, bind_with, col, ints, lit, run, strs}; +use arrow_array::types::Int32Type; + +fn last_win() -> BindOptions { + BindOptions::new().with_map_key_dedup_policy(DedupPolicy::LastWin) +} + +type Pairs = Vec)>>>; + +fn view_pairs(m: &MapArray) -> Pairs { + let key = |p: usize| match m.keys().data_type() { + DataType::Int32 => m.keys().as_primitive::().value(p).to_string(), + _ => m.keys().as_string_view().value(p).to_owned(), + }; + (0..m.len()) + .map(|r| { + if m.is_null(r) { + return None; + } + let offsets = m.value_offsets(); + let (from, to) = ( + usize::try_from(offsets[r]).unwrap_or(0), + usize::try_from(offsets[r + 1]).unwrap_or(0), + ); + let mut row = Vec::new(); + for p in from..to { + let v = m + .values() + .is_valid(p) + .then(|| m.values().as_string_view().value(p).to_owned()); + row.push((key(p), v)); + } + Some(row) + }) + .collect() +} + +/// `map(k, v)` over two columns, as the analyzer casts them. +fn int_str_map(keys: &ArrayRef, values: &ArrayRef) -> ArrayRef { + run("map", &[keys, values]) +} + +#[test] +fn map_builds_a_map_per_row() { + let keys = ints(&[Some(1), Some(2), Some(1)]); + let values = strs(&[Some("a"), None, Some("c")]); + let out = int_str_map(&keys, &values); + // Keys are `Int32`, values the canonical `Utf8View`. + assert_eq!( + out.data_type(), + &DataType::Map( + Arc::new(Field::new( + "entries", + DataType::Struct( + vec![ + Field::new("key", DataType::Int32, false), + Field::new("value", DataType::Utf8View, true), + ] + .into(), + ), + false, + )), + false, + ) + ); + let m = out.as_map(); + assert_eq!( + view_pairs(m), + [ + Some(vec![("1".to_owned(), Some("a".to_owned()))]), + Some(vec![("2".to_owned(), None)]), + Some(vec![("1".to_owned(), Some("c".to_owned()))]), + ] + ); +} + +#[test] +fn map_value_nullability_follows_the_arguments() { + let keys = ints(&[Some(1)]); + let values = strs(&[Some("a")]); + // Nullable value columns give nullable map values; literals do not. + let bound = vec![ + BindArg::Column { + ty: DataType::Int32, + nullable: false, + }, + BindArg::Column { + ty: DataType::Utf8, + nullable: true, + }, + ]; + let f = bind_scalar("map", &bound, &BindOptions::new()).unwrap(); + let nullable = match f.return_type() { + DataType::Map(entries, _) => match entries.data_type() { + DataType::Struct(fs) => fs[1].is_nullable(), + _ => false, + }, + _ => false, + }; + assert!(nullable); + let lit_args = vec![ + BindArg::Literal(Arc::clone(&keys)), + BindArg::Literal(Arc::clone(&values)), + ]; + let f = bind_scalar("map", &lit_args, &BindOptions::new()).unwrap(); + let nullable = match f.return_type() { + DataType::Map(entries, _) => match entries.data_type() { + DataType::Struct(fs) => fs[1].is_nullable(), + _ => true, + }, + _ => true, + }; + assert!(!nullable); +} + +#[test] +fn map_rejects_null_and_duplicate_keys() { + let keys = ints(&[Some(1), None]); + let values = strs(&[Some("a"), Some("b")]); + let e = bind("map", &[&keys, &values]) + .invoke(&[col(&keys), col(&values)], 2) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::NullMapKey); + + // A null key still fails under `LAST_WIN`. + let keys = ints(&[None]); + let values = strs(&[Some("a")]); + let f = bind_with("map", &[&keys, &values], &last_win()); + let e = f.invoke(&[col(&keys), col(&values)], 1).unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::NullMapKey); + + // Duplicate keys within a row. + let k1 = ints(&[Some(1), Some(1)]); + let v1 = strs(&[Some("a"), Some("x")]); + let k2 = ints(&[Some(1), Some(1)]); + let v2 = strs(&[Some("b"), Some("y")]); + let e = bind("map", &[&k1, &v1, &k2, &v2]) + .invoke(&[col(&k1), col(&v1), col(&k2), col(&v2)], 2) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::DuplicatedMapKey); + + // `LAST_WIN` keeps the last value. + let f = bind_with("map", &[&k1, &v1, &k2, &v2], &last_win()); + let out = f + .invoke(&[col(&k1), col(&v1), col(&k2), col(&v2)], 2) + .unwrap(); + assert_eq!( + view_pairs(out.as_map()), + [ + Some(vec![("1".to_owned(), Some("b".to_owned()))]), + Some(vec![("1".to_owned(), Some("y".to_owned()))]), + ] + ); +} + +#[test] +fn map_rejects_wrong_shapes() { + // Odd arguments and non-key types never bind. + assert!( + bind_scalar( + "map", + &[BindArg::from(DataType::Int32)], + &BindOptions::new() + ) + .is_err() + ); + let fields: arrow_schema::Fields = vec![Field::new("f", DataType::Int32, true)].into(); + let st = Arc::new( + StructBuilder::new( + fields, + vec![Box::new(Int32Builder::new()) as Box], + ) + .finish(), + ) as ArrayRef; + assert!( + bind_scalar( + "map", + &[BindArg::Literal(st), BindArg::from(DataType::Int32)], + &BindOptions::new(), + ) + .is_err() + ); +} + +#[test] +fn map_concat_merges_in_order() { + let left = int_str_map(&ints(&[Some(1)]), &strs(&[Some("a")])); + let right = int_str_map(&ints(&[Some(2)]), &strs(&[Some("b")])); + let out = run("map_concat", &[&left, &right]); + assert_eq!( + view_pairs(out.as_map()), + [Some(vec![ + ("1".to_owned(), Some("a".to_owned())), + ("2".to_owned(), Some("b".to_owned())), + ])] + ); + + // No maps is an empty map per row. + let f = bind_scalar("map_concat", &[], &BindOptions::new()).unwrap(); + assert_eq!( + f.return_type(), + &DataType::Map( + Arc::new(Field::new( + "entries", + DataType::Struct( + vec![ + Field::new("key", DataType::Utf8View, false), + Field::new("value", DataType::Utf8View, true), + ] + .into(), + ), + false, + )), + false, + ) + ); + assert_eq!(f.invoke(&[], 2).unwrap().len(), 2); + + // A null map voids its row under either policy. + let null_keys = arrow_array::new_null_array( + &DataType::List(Arc::new(Field::new("item", DataType::Int32, true))), + 1, + ); + let null_values = arrow_array::new_null_array( + &DataType::List(Arc::new(Field::new("item", DataType::Utf8, true))), + 1, + ); + let null = run("map_from_arrays", &[&null_keys, &null_values]); + assert_eq!(null.null_count(), 1); + + // Duplicates follow the policy. + let e = bind("map_concat", &[&left, &left]) + .invoke(&[col(&left), col(&left)], 1) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::DuplicatedMapKey); + + // Non-maps and untyped nulls never bind. + assert!( + bind_scalar( + "map_concat", + &[ + BindArg::from(DataType::Int32), + BindArg::from(DataType::Int32) + ], + &BindOptions::new(), + ) + .is_err() + ); +} + +#[test] +fn map_contains_key_compares() { + let map = int_str_map(&ints(&[Some(1), Some(2)]), &strs(&[Some("a"), Some("b")])); + let one = ints(&[Some(1), Some(3)]); + let out = run("map_contains_key", &[&map, &one]); + assert_eq!( + out.as_boolean().iter().collect::>(), + [Some(true), Some(false)] + ); + // A null map or key is null; an untyped null key never binds. + let null = arrow_array::new_null_array(out.data_type(), 2); + let out = run("map_contains_key", &[&map, &null]); + assert_eq!(out.null_count(), 2); + assert!( + bind_scalar( + "map_contains_key", + &[ + BindArg::from(DataType::Int32), + BindArg::from(DataType::Int32) + ], + &BindOptions::new(), + ) + .is_err() + ); +} + +#[test] +fn map_projections_share_rows() { + let map = int_str_map(&ints(&[Some(1), Some(2)]), &strs(&[Some("a"), None])); + let keys = run("map_keys", &[&map]); + assert_eq!( + keys.as_list::() + .values() + .as_primitive::() + .values(), + &[1, 2] + ); + let values = run("map_values", &[&map]); + assert_eq!(values.null_count(), 0); + assert_eq!(values.as_list::().values().null_count(), 1); + let entries = run("map_entries", &[&map]); + let list = entries.as_list::(); + assert_eq!(list.len(), 2); + let structs = list.values().as_struct(); + assert_eq!(structs.num_columns(), 2); + assert_eq!(structs.len(), 2); +} + +fn int_list(values: &[Option], breaks: &[usize]) -> ArrayRef { + let mut b = ListBuilder::new(Int32Builder::new()); + let mut at = 0_usize; + for n in breaks { + let n = *n; + for v in &values[at..at.saturating_add(n)] { + match v { + Some(v) => b.values().append_value(*v), + None => b.values().append_null(), + } + } + at = at.saturating_add(n); + b.append(true); + } + Arc::new(b.finish()) +} + +fn str_list(values: &[Option<&str>], breaks: &[usize]) -> ArrayRef { + let mut b = ListBuilder::new(StringBuilder::new()); + let mut at = 0_usize; + for n in breaks { + let n = *n; + for v in &values[at..at.saturating_add(n)] { + match v { + Some(v) => b.values().append_value(v), + None => b.values().append_null(), + } + } + at = at.saturating_add(n); + b.append(true); + } + Arc::new(b.finish()) +} + +#[test] +fn map_from_arrays_maps_slices() { + let keys = int_list(&[Some(1), Some(2)], &[2]); + let values = str_list(&[Some("a"), Some("b")], &[2]); + let out = run("map_from_arrays", &[&keys, &values]); + let m = out.as_map(); + assert_eq!(m.len(), 1); + assert_eq!( + view_pairs(m), + [Some(vec![ + ("1".to_owned(), Some("a".to_owned())), + ("2".to_owned(), Some("b".to_owned())), + ])] + ); + + // Slices of different lengths are `_LEGACY_ERROR_TEMP_2128`. + let short = int_list(&[Some(1)], &[1]); + let e = bind("map_from_arrays", &[&short, &values]) + .invoke(&[col(&short), col(&values)], 1) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::LegacyErrorTemp2128); + + // A null key element is `NULL_MAP_KEY`. + let null_key = int_list(&[Some(1), None], &[2]); + let e = bind("map_from_arrays", &[&null_key, &values]) + .invoke(&[col(&null_key), col(&values)], 1) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::NullMapKey); + + // Duplicates follow the policy. + let dup = int_list(&[Some(1), Some(1)], &[2]); + let e = bind("map_from_arrays", &[&dup, &values]) + .invoke(&[col(&dup), col(&values)], 1) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::DuplicatedMapKey); + let f = bind_with("map_from_arrays", &[&dup, &values], &last_win()); + let out = f.invoke(&[col(&dup), col(&values)], 1).unwrap(); + assert_eq!( + view_pairs(out.as_map()), + [Some(vec![("1".to_owned(), Some("b".to_owned()))])] + ); +} + +fn struct_list(keys: &ArrayRef, values: &ArrayRef, breaks: &[usize], nulls: &[bool]) -> ArrayRef { + // keys/values hold every row's entries in order; `breaks[r]` counts + // row r's. + let fields: arrow_schema::Fields = vec![ + Field::new("key", DataType::Int32, true), + Field::new("value", DataType::Utf8View, true), + ] + .into(); + let mut key_builder = Int32Builder::new(); + let mut value_builder = arrow_array::builder::StringViewBuilder::new(); + let va = values.as_string::(); + let mut at = 0_usize; + let mut offsets = vec![0_i32]; + for (r, n) in breaks.iter().enumerate() { + if nulls[r] { + offsets.push(offsets[offsets.len() - 1]); + continue; + } + let ka = keys.as_primitive::(); + for _ in 0..*n { + if ka.is_null(at) { + key_builder.append_null(); + } else { + key_builder.append_value(ka.value(at)); + } + if va.is_null(at) { + value_builder.append_null(); + } else { + value_builder.append_value(va.value(at)); + } + at = at.saturating_add(1); + } + offsets.push(i32::try_from(key_builder.len()).unwrap_or(i32::MAX)); + } + let structs = StructArray::new( + fields, + vec![ + Arc::new(key_builder.finish()) as ArrayRef, + Arc::new(value_builder.finish()), + ], + None, + ); + Arc::new(arrow_array::ListArray::new( + Arc::new(Field::new( + "item", + DataType::Struct( + vec![ + Field::new("key", DataType::Int32, true), + Field::new("value", DataType::Utf8View, true), + ] + .into(), + ), + true, + )), + arrow_buffer::OffsetBuffer::new(offsets.into()), + Arc::new(structs), + nulls + .iter() + .any(|n| *n) + .then(|| NullBuffer::from_iter(nulls.iter().map(|n| !n))), + )) +} + +#[test] +fn map_from_entries_maps_structs() { + let keys = ints(&[Some(1), Some(2)]); + let values = strs(&[Some("a"), Some("b")]); + let array = struct_list(&keys, &values, &[2], &[false]); + let out = run("map_from_entries", &[&array]); + assert_eq!( + view_pairs(out.as_map()), + [Some(vec![ + ("1".to_owned(), Some("a".to_owned())), + ("2".to_owned(), Some("b".to_owned())), + ])] + ); + + // A null element voids the whole result. + let array = struct_list(&keys, &values, &[2], &[true]); + let out = run("map_from_entries", &[&array]); + assert_eq!(out.null_count(), 1); + + // A null key field is `NULL_MAP_KEY`. + let keys = ints(&[None]); + let values = strs(&[Some("a")]); + let array = struct_list(&keys, &values, &[1], &[false]); + let e = bind("map_from_entries", &[&array]) + .invoke(&[col(&array)], 1) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::NullMapKey); + + // Anything but an array of pairs never binds. + assert!( + bind_scalar( + "map_from_entries", + &[BindArg::from(DataType::Int32)], + &BindOptions::new() + ) + .is_err() + ); +} + +#[test] +fn str_to_map_splits_rows() { + let text = strs(&[Some("a:1,b:2,c:3"), Some(""), None]); + let out = run("str_to_map", &[&text]); + assert_eq!( + view_pairs(out.as_map()), + [ + Some(vec![ + ("a".to_owned(), Some("1".to_owned())), + ("b".to_owned(), Some("2".to_owned())), + ("c".to_owned(), Some("3".to_owned())), + ]), + Some(vec![("".to_owned(), None)]), + None, + ] + ); + + // Custom delimiters, and a missing value is null. + let pair = strs(&[Some(";")]); + let kv = strs(&[Some("=")]); + let f = bind_scalar( + "str_to_map", + &[ + BindArg::from(DataType::Utf8), + BindArg::Literal(Arc::clone(&pair)), + BindArg::Literal(Arc::clone(&kv)), + ], + &BindOptions::new(), + ) + .unwrap(); + let text = strs(&[Some("a=1;b")]); + let out = f.invoke(&[col(&text), lit(&pair), lit(&kv)], 1).unwrap(); + assert_eq!( + view_pairs(out.as_map()), + [Some(vec![ + ("a".to_owned(), Some("1".to_owned())), + ("b".to_owned(), None), + ])] + ); + + // Duplicate keys follow the policy. + let dup = strs(&[Some("a:1,a:2")]); + let e = bind("str_to_map", &[&dup]) + .invoke(&[col(&dup)], 1) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::DuplicatedMapKey); + let f = bind_with("str_to_map", &[&dup], &last_win()); + let out = f.invoke(&[col(&dup)], 1).unwrap(); + assert_eq!( + view_pairs(out.as_map()), + [Some(vec![("a".to_owned(), Some("2".to_owned())),])] + ); +} diff --git a/crates/krishiv-functions/src/scalar/tests/mod.rs b/crates/krishiv-functions/src/scalar/tests/mod.rs index b9d5c8fe0..61b9fe5fb 100644 --- a/crates/krishiv-functions/src/scalar/tests/mod.rs +++ b/crates/krishiv-functions/src/scalar/tests/mod.rs @@ -591,6 +591,7 @@ fn results_are_checked_against_the_binding() { mod bitwise; mod calendar; mod families; +mod map; mod misc; mod number; mod predicate; diff --git a/crates/krishiv-functions/src/signature.rs b/crates/krishiv-functions/src/signature.rs index cbf750429..2e0b9dc26 100644 --- a/crates/krishiv-functions/src/signature.rs +++ b/crates/krishiv-functions/src/signature.rs @@ -303,6 +303,11 @@ pub enum InputType { /// Whether Spark's required type names ANSI intervals. intervals: bool, }, + /// Any map type; an untyped `NULL` becomes `map` (Spark's + /// implicit cast of `NULL` to the abstract map type). + Map, + /// Any array type; an untyped `NULL` becomes `array`. + Array, /// One of these types (Spark's `TypeCollection`): an argument of one of /// them stays as it is, another is cast to the first it may be cast to /// implicitly. @@ -316,6 +321,8 @@ impl InputType { match self { Self::Any => "\"ANY\"".to_owned(), Self::Exact(t) | Self::Strict(t) => format!("\"{}\"", t.sql()), + Self::Map => "\"MAP\"".to_owned(), + Self::Array => "\"ARRAY\"".to_owned(), Self::Numeric { intervals: false } => "\"NUMERIC\"".to_owned(), Self::Numeric { intervals: true } => "\"NUMERIC\" or \"ANSI INTERVAL\"".to_owned(), // Spark's `AnyTimestampType` names itself in words. @@ -379,6 +386,19 @@ pub enum Inputs { /// Argument `i` takes `types[i]`; the last type repeats for further /// arguments. Expects(Vec), + /// `map(k1, v1, ...)`: the keys (even positions) and the values (odd) + /// each take the type they meet at; `CREATE_MAP_KEY_DIFF_TYPES` and + /// `CREATE_MAP_VALUE_DIFF_TYPES` when either side has none. + Map, + /// `map_concat(m1, ...)`: every argument must be a map + /// (`MAP_CONCAT_DIFF_TYPES` otherwise, an untyped `NULL` included); + /// with ANSI they must share the type ignoring nullability, without it + /// they meet at their common type (`DATA_DIFF_TYPES` either way). + MapConcat, + /// `map_contains_key(map, key)`: the key meets the map's key type + /// without string promotion, and both are cast to the wider key type; + /// no casts when there is none (the result rule reports it). + MapContainsKey, /// Every argument takes the type all of them meet at (`coalesce`); /// `DATATYPE_MISMATCH.DATA_DIFF_TYPES` when there is none. Common, @@ -425,6 +445,9 @@ impl Inputs { | Self::CommonNoStrings | Self::Leading(_) | Self::CommonWithZero + | Self::Map + | Self::MapConcat + | Self::MapContainsKey | Self::Comparable { .. } | Self::NullSafeEqual | Self::Operator(_) diff --git a/crates/krishiv-kernels/CLAUDE.md b/crates/krishiv-kernels/CLAUDE.md index ea881c185..6e2db6122 100644 --- a/crates/krishiv-kernels/CLAUDE.md +++ b/crates/krishiv-kernels/CLAUDE.md @@ -56,6 +56,11 @@ Vectorised compute kernels (SIMD) with Spark semantics, Spark-observable Murmur3 view, offset and narrow-decimal carriers hash as their values), key groups (top 12 bits) and key-group-range partitioning (`partition_of`, `key_group_range`, `radix`). It is a format: `tests/routing.rs` pins golden vectors, and a change is a new version and a new plan-codec feature, never an edit. +- `map` (P2-T029): the map functions over `MapArray`/`ListArray`/`StructArray` (offsets and child values, never + boxed): `map`, `map_concat`, `map_contains_key`, `map_keys`, `map_values`, `map_entries`, `map_from_arrays`, + `map_from_entries` and `str_to_map`. Keys compare with Spark's equality and hash with the observable Murmur3 + (NaN equals NaN, `-0.0` equals `0.0`); a null key is `NULL_MAP_KEY`, a repeat `DUPLICATED_MAP_KEY` under + `EXCEPTION` and last-wins under `LAST_WIN`. - `datetime` (P2-T025a): `date_add`/`date_sub`/`date_diff` (ANSI: `ARITHMETIC_OVERFLOW` past the `int` range, a documented divergence from Spark; legacy: Java `int` wrap; `try_*`: NULL), field extraction (`DatePart`: `year`, `month`, `day`, `extract`/`date_part` incl. ISO week and `SECOND` as `decimal(8,6)`), `date`/`timestamp` ± interval (`date_add_months` clamps the day; `timestamp_add_day_time` adds whole @@ -91,6 +96,7 @@ Paths are relative to this crate. - `src/integer.rs`, `src/decimal.rs`, `src/float.rs` arithmetic kernels; `src/compare.rs` comparisons - `src/cast.rs` Spark CAST on Arrow carriers; `src/string.rs` string kernels - `src/hash.rs` and `src/hash/murmur3.rs` Murmur3 (seed 42), `src/hash/xxh64.rs` xxhash64, `src/hash/routing.rs` `H_kg` +- `src/map.rs` map functions over nested arrays - `src/datetime.rs` date and timestamp kernels; `src/math.rs` double functions, `src/math/fdlibm.rs` ports - `src/reference.rs` row-at-a-time oracle for property tests diff --git a/crates/krishiv-kernels/src/lib.rs b/crates/krishiv-kernels/src/lib.rs index a837f181d..0ddae4dcd 100644 --- a/crates/krishiv-kernels/src/lib.rs +++ b/crates/krishiv-kernels/src/lib.rs @@ -49,6 +49,7 @@ pub mod float; pub mod hash; pub mod integer; pub mod list; +pub mod map; pub mod math; pub mod number_format; pub mod ops; diff --git a/crates/krishiv-kernels/src/map.rs b/crates/krishiv-kernels/src/map.rs new file mode 100644 index 000000000..bdbee6d4a --- /dev/null +++ b/crates/krishiv-kernels/src/map.rs @@ -0,0 +1,1944 @@ +// SPDX-License-Identifier: Apache-2.0 +//! Spark map functions over Arrow nested data: `map`, `map_concat`, +//! `map_contains_key`, `map_keys`, `map_values`, `map_entries`, +//! `map_from_arrays`, `map_from_entries` and `str_to_map`. +//! +//! Every builder works row by row over Arrow arrays directly (offsets and +//! child values, as the string kernels do): keys and values are never boxed +//! into a row enum. A row's entries are deduplicated by their Murmur3 hash +//! ([`crate::hash`], the observable Spark hash, which normalises `-0.0` and +//! NaN exactly as Spark's map-key normaliser does) and confirmed with +//! [`keys_equal`]; a hash collision only costs a comparison. Key equality is +//! Spark's: NaN equals NaN, `-0.0` equals `0.0`, strings and binary compare +//! byte-wise (the default binary collation) and arrays and structs compare +//! element by element, where two nulls are equal. +//! +//! A `NULL` key is `NULL_MAP_KEY` the moment it is met, in row-major pair +//! order, as Spark's builders raise it. A duplicate key is +//! `DUPLICATED_MAP_KEY` under the `EXCEPTION` policy and overwrites the +//! first value under `LAST_WIN` (keeping the first position, as Spark's +//! builder does). + +use std::collections::HashMap; +use std::sync::Arc; + +use arrow_array::builder::{ + ArrayBuilder, BooleanBuilder, Date32Builder, Decimal128Builder, Float32Builder, Float64Builder, + Int8Builder, Int16Builder, Int32Builder, Int64Builder, ListBuilder, MapBuilder, NullBuilder, + StringViewBuilder, StructBuilder, TimestampMicrosecondBuilder, UInt8Builder, UInt16Builder, + UInt32Builder, UInt64Builder, make_builder, +}; +use arrow_array::cast::AsArray; +use arrow_array::types::{ + Date32Type, Decimal128Type, Float32Type, Float64Type, Int8Type, Int16Type, Int32Type, + Int64Type, TimestampMicrosecondType, UInt8Type, UInt16Type, UInt32Type, UInt64Type, +}; +use arrow_array::{ + Array, ArrayRef, BooleanArray, GenericListArray, ListArray, MapArray, StructArray, +}; +use arrow_buffer::{ArrowNativeType, NullBuffer, NullBufferBuilder, OffsetBuffer}; +use arrow_schema::{DataType, FieldRef, TimeUnit}; +use krishiv_common::error::{DuplicatedMapKey, KrishivError, LegacyErrorTemp2128, NullMapKey}; + +use crate::compare::SparkOrd; +use crate::error::KernelError; +use crate::hash; + +/// How duplicate map keys resolve (`spark.sql.mapKeyDedupPolicy`). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum DedupPolicy { + /// Fail the query (`DUPLICATED_MAP_KEY`). + Exception, + /// The value inserted last wins. + LastWin, +} + +impl DedupPolicy { + /// The policy of the session value (`EXCEPTION` when unset; the config + /// registry only allows the two spellings). + #[must_use] + pub fn of(value: Option<&str>) -> Self { + match value { + Some("LAST_WIN") => Self::LastWin, + _ => Self::Exception, + } + } +} + +/// Whether the kernel builds maps over keys of Arrow type `t`: the types +/// the analyzer's casts produce (integers, floats, decimals, strings, +/// binary, dates, microsecond timestamps, and arrays and structs of those). +/// Anything else (a map, dictionary, union, interval, time of day, decimal +/// beyond 128 bits, non-microsecond timestamps) cannot arrive here; the +/// binding refuses it first. +#[must_use] +pub fn supports_key(t: &DataType) -> bool { + match t { + DataType::Null + | DataType::Boolean + | DataType::Int8 + | DataType::Int16 + | DataType::Int32 + | DataType::Int64 + | DataType::UInt8 + | DataType::UInt16 + | DataType::UInt32 + | DataType::UInt64 + | DataType::Float32 + | DataType::Float64 + | DataType::Decimal128(..) + | DataType::Utf8 + | DataType::Utf8View + | DataType::LargeUtf8 + | DataType::Binary + | DataType::BinaryView + | DataType::LargeBinary + | DataType::Date32 + | DataType::Timestamp(TimeUnit::Microsecond, _) => true, + DataType::List(f) | DataType::LargeList(f) => supports_key(f.data_type()), + DataType::Struct(fs) => fs.iter().all(|f| supports_value(f.data_type())), + _ => false, + } +} + +/// Whether the kernel stores values of Arrow type `t`: the key types, plus +/// maps of those (a map value may itself be a map). +#[must_use] +pub fn supports_value(t: &DataType) -> bool { + if supports_key(t) { + return true; + } + match t { + DataType::Map(entries, _) => match entries.data_type() { + DataType::Struct(fs) if fs.len() == 2 => { + supports_key(fs[0].data_type()) && supports_value(fs[1].data_type()) + } + _ => false, + }, + _ => false, + } +} + +fn internal(e: impl std::fmt::Display) -> KernelError { + KernelError::internal(e.to_string()) +} + +/// The hash at `at`: a missing entry means the hash run is shorter than the +/// entries it dedups, which is an internal error rather than a hash of zero. +fn hash_at(hash: &[i32], at: usize) -> Result { + hash.get(at) + .copied() + .ok_or_else(|| internal("map entries past their hashes")) +} + +/// Spark's equality of two key values: `a[i] = b[j]`. Both sides already +/// share the Spark type (the analyzer cast them), but their carriers may +/// differ (a plain `Utf8` against a view, a `List` against a `LargeList`). +/// Floats use [`SparkOrd`] (NaN equals NaN, `-0.0` equals `0.0`); nested +/// values compare element by element with two nulls equal. +/// +/// # Errors +/// `INTERNAL_ERROR` for a type [`supports_key`] refuses (unreachable: the +/// binding checks first). +pub fn keys_equal(a: &dyn Array, i: usize, b: &dyn Array, j: usize) -> Result { + use DataType as T; + if a.is_null(i) || b.is_null(j) { + return Ok(a.is_null(i) && b.is_null(j)); + } + match (a.data_type(), b.data_type()) { + (T::Null, T::Null) => Ok(true), + (T::Boolean, T::Boolean) => Ok(a.as_boolean().value(i) == b.as_boolean().value(j)), + (T::Int8, T::Int8) => { + Ok(a.as_primitive::().value(i) == b.as_primitive::().value(j)) + } + (T::Int16, T::Int16) => { + Ok(a.as_primitive::().value(i) == b.as_primitive::().value(j)) + } + (T::Int32, T::Int32) => { + Ok(a.as_primitive::().value(i) == b.as_primitive::().value(j)) + } + (T::Int64, T::Int64) => { + Ok(a.as_primitive::().value(i) == b.as_primitive::().value(j)) + } + (T::UInt8, T::UInt8) => { + Ok(a.as_primitive::().value(i) == b.as_primitive::().value(j)) + } + (T::UInt16, T::UInt16) => { + Ok(a.as_primitive::().value(i) == b.as_primitive::().value(j)) + } + (T::UInt32, T::UInt32) => { + Ok(a.as_primitive::().value(i) == b.as_primitive::().value(j)) + } + (T::UInt64, T::UInt64) => { + Ok(a.as_primitive::().value(i) == b.as_primitive::().value(j)) + } + (T::Float32, T::Float32) => Ok(f32::spark_eq( + a.as_primitive::().value(i), + b.as_primitive::().value(j), + )), + (T::Float64, T::Float64) => Ok(f64::spark_eq( + a.as_primitive::().value(i), + b.as_primitive::().value(j), + )), + (T::Decimal128(..), T::Decimal128(..)) => Ok(a.as_primitive::().value(i) + == b.as_primitive::().value(j)), + (x, y) if is_string(x) && is_string(y) => Ok(string_value(a, i) == string_value(b, j)), + (x, y) if is_binary(x) && is_binary(y) => Ok(binary_value(a, i) == binary_value(b, j)), + (T::Date32, T::Date32) => { + Ok(a.as_primitive::().value(i) == b.as_primitive::().value(j)) + } + (T::Timestamp(TimeUnit::Microsecond, _), T::Timestamp(TimeUnit::Microsecond, _)) => { + Ok(a.as_primitive::().value(i) + == b.as_primitive::().value(j)) + } + (T::List(_) | T::LargeList(_), T::List(_) | T::LargeList(_)) => list_equal(a, i, b, j), + (T::Struct(_), T::Struct(_)) => struct_equal(a.as_struct(), i, b.as_struct(), j), + (x, y) => Err(internal(format!( + "map keys of {x} and {y} are not comparable" + ))), + } +} + +fn is_string(t: &DataType) -> bool { + matches!(t, DataType::Utf8 | DataType::Utf8View | DataType::LargeUtf8) +} + +fn is_binary(t: &DataType) -> bool { + matches!( + t, + DataType::Binary | DataType::BinaryView | DataType::LargeBinary + ) +} + +fn string_value(a: &dyn Array, i: usize) -> &str { + match a.data_type() { + DataType::Utf8 => a.as_string::().value(i), + DataType::LargeUtf8 => a.as_string::().value(i), + _ => a.as_string_view().value(i), + } +} + +fn binary_value(a: &dyn Array, i: usize) -> &[u8] { + match a.data_type() { + DataType::Binary => a.as_binary::().value(i), + DataType::LargeBinary => a.as_binary::().value(i), + _ => a.as_binary_view().value(i), + } +} + +/// The child range of list row `i`, whatever the offset width. +fn list_range(a: &dyn Array, i: usize) -> Result<(usize, usize), KernelError> { + let err = || internal("a list row past its offsets"); + let (start, end) = match a.data_type() { + DataType::List(_) => { + let off = a.as_list::().value_offsets(); + let (Some(s), Some(e)) = (off.get(i), off.get(i.saturating_add(1))) else { + return Err(err()); + }; + (s.as_usize(), e.as_usize()) + } + DataType::LargeList(_) => { + let off = a.as_list::().value_offsets(); + let (Some(s), Some(e)) = (off.get(i), off.get(i.saturating_add(1))) else { + return Err(err()); + }; + (s.as_usize(), e.as_usize()) + } + t => return Err(internal(format!("a list row of type {t}"))), + }; + Ok((start, end)) +} + +fn list_values(a: &dyn Array) -> ArrayRef { + match a.data_type() { + DataType::List(_) => Arc::clone(a.as_list::().values()), + _ => Arc::clone(a.as_list::().values()), + } +} + +fn list_equal(a: &dyn Array, i: usize, b: &dyn Array, j: usize) -> Result { + let (from, to) = list_range(a, i)?; + let (other_from, other_to) = list_range(b, j)?; + let (len, other_len) = (to.saturating_sub(from), other_to.saturating_sub(other_from)); + if len != other_len { + return Ok(false); + } + let (values, other) = (list_values(a), list_values(b)); + for k in 0..len { + let (x, y) = (from.saturating_add(k), other_from.saturating_add(k)); + if !keys_equal(values.as_ref(), x, other.as_ref(), y)? { + return Ok(false); + } + } + Ok(true) +} + +fn struct_equal(a: &StructArray, i: usize, b: &StructArray, j: usize) -> Result { + let (DataType::Struct(af), DataType::Struct(bf)) = (a.data_type(), b.data_type()) else { + return Err(internal("a struct key without struct fields")); + }; + if af.len() != bf.len() { + return Ok(false); + } + for (x, y) in a.columns().iter().zip(b.columns()) { + if !keys_equal(x.as_ref(), i, y.as_ref(), j)? { + return Ok(false); + } + } + Ok(true) +} + +/// Appends `array[idx]` to `builder`, whose type is the canonical carrier +/// of `array`'s Spark type (views for strings and binary). A null appends +/// null; a null struct appends nulls to every field, which readers ignore. +/// +/// # Errors +/// `INTERNAL_ERROR` for a type [`supports_value`] refuses, or when the +/// builder and the value disagree (both unreachable: the binding checks the +/// types and builds the builders from the same output field). +#[expect(clippy::too_many_lines, reason = "one arm per Arrow carrier")] +fn append_value( + builder: &mut dyn ArrayBuilder, + array: &dyn Array, + idx: usize, +) -> Result<(), KernelError> { + use DataType as T; + macro_rules! prim { + ($t:ty, $b:ty) => {{ + let a = array + .as_primitive_opt::<$t>() + .ok_or_else(|| internal("a map value of the wrong type"))?; + let b = builder + .as_any_mut() + .downcast_mut::<$b>() + .ok_or_else(|| internal("a map builder of the wrong type"))?; + if a.is_null(idx) { + b.append_null(); + } else { + b.append_value(a.value(idx)); + } + Ok(()) + }}; + } + match array.data_type() { + T::Null => { + downcast::(builder)?.append_null(); + Ok(()) + } + T::Boolean => { + let (a, b) = (array.as_boolean(), downcast::(builder)?); + if a.is_null(idx) { + b.append_null(); + } else { + b.append_value(a.value(idx)); + } + Ok(()) + } + T::Int8 => prim!(Int8Type, Int8Builder), + T::Int16 => prim!(Int16Type, Int16Builder), + T::Int32 => prim!(Int32Type, Int32Builder), + T::Int64 => prim!(Int64Type, Int64Builder), + T::UInt8 => prim!(UInt8Type, UInt8Builder), + T::UInt16 => prim!(UInt16Type, UInt16Builder), + T::UInt32 => prim!(UInt32Type, UInt32Builder), + T::UInt64 => prim!(UInt64Type, UInt64Builder), + T::Float32 => prim!(Float32Type, Float32Builder), + T::Float64 => prim!(Float64Type, Float64Builder), + T::Decimal128(..) => prim!(Decimal128Type, Decimal128Builder), + t if is_string(t) => { + let b = downcast::(builder)?; + if array.is_null(idx) { + b.append_null(); + } else { + b.append_value(string_value(array, idx)); + } + Ok(()) + } + t if is_binary(t) => { + let b = downcast::(builder)?; + if array.is_null(idx) { + b.append_null(); + } else { + b.append_value(binary_value(array, idx)); + } + Ok(()) + } + T::Date32 => prim!(Date32Type, Date32Builder), + T::Timestamp(TimeUnit::Microsecond, _) => { + prim!(TimestampMicrosecondType, TimestampMicrosecondBuilder) + } + T::List(_) | T::LargeList(_) => { + if array.is_null(idx) { + append_list_null(builder)?; + return Ok(()); + } + let (from, to) = list_range(array, idx)?; + append_list(builder, list_values(array).as_ref(), from, to) + } + T::Struct(_) => { + let a = array.as_struct(); + let b = downcast::(builder)?; + if array.is_null(idx) { + for (f, col) in b.field_builders_mut().iter_mut().zip(a.columns()) { + append_value(f.as_mut(), col.as_ref(), idx)?; + } + b.append(false); + return Ok(()); + } + for (f, col) in b.field_builders_mut().iter_mut().zip(a.columns()) { + append_value(f.as_mut(), col.as_ref(), idx)?; + } + b.append(true); + Ok(()) + } + T::Map(..) => { + let Some(a) = array.as_map_opt() else { + return Err(internal("a map value without map data")); + }; + let b = downcast::, Box>>(builder)?; + if array.is_null(idx) { + b.append(false).map_err(internal)?; + return Ok(()); + } + let (from, to) = map_range(a, idx)?; + for p in from..to { + append_value(b.keys().as_mut(), a.keys().as_ref(), p)?; + append_value(b.values().as_mut(), a.values().as_ref(), p)?; + } + b.append(true).map_err(internal)?; + Ok(()) + } + t => Err(internal(format!("a map value of type {t}"))), + } +} + +fn downcast(builder: &mut dyn ArrayBuilder) -> Result<&mut B, KernelError> { + builder + .as_any_mut() + .downcast_mut::() + .ok_or_else(|| internal("a map builder of the wrong type")) +} + +type DynListBuilder = ListBuilder>; +type DynLargeListBuilder = arrow_array::builder::LargeListBuilder>; + +fn append_list( + builder: &mut dyn ArrayBuilder, + values: &dyn Array, + from: usize, + to: usize, +) -> Result<(), KernelError> { + if let Some(b) = builder.as_any_mut().downcast_mut::() { + for p in from..to { + append_value(b.values().as_mut(), values, p)?; + } + b.append(true); + return Ok(()); + } + let b = downcast::(builder)?; + for p in from..to { + append_value(b.values().as_mut(), values, p)?; + } + b.append(true); + Ok(()) +} + +fn append_list_null(builder: &mut dyn ArrayBuilder) -> Result<(), KernelError> { + if let Some(b) = builder.as_any_mut().downcast_mut::() { + b.append(false); + return Ok(()); + } + downcast::(builder)?.append(false); + Ok(()) +} + +/// The child range of map row `i`. +fn map_range(m: &MapArray, i: usize) -> Result<(usize, usize), KernelError> { + let offsets = m.value_offsets(); + let (Some(from), Some(to)) = (offsets.get(i), offsets.get(i.saturating_add(1))) else { + return Err(internal("a map row past its offsets")); + }; + Ok((from.as_usize(), to.as_usize())) +} + +/// One entry of a row under construction: the key and value arrays and +/// their positions. Positions only; values are read once, when the entry +/// survives deduplication. +#[derive(Clone, Copy)] +struct Entry<'a> { + keys: &'a dyn Array, + key: usize, + values: &'a dyn Array, + value: usize, +} + +/// The deduplicated entries of every row, in first-occurrence order with +/// the value position remapped under `LAST_WIN`. +struct Deduped<'a> { + rows: Vec>>, +} + +impl<'a> Deduped<'a> { + /// Deduplicates `per_row` in order against `hash` (its entries in + /// row-major entry order): a null key is `NULL_MAP_KEY`, a repeat is + /// `DUPLICATED_MAP_KEY` under `EXCEPTION` and overwrites the value + /// under `LAST_WIN`. + fn of( + per_row: Vec>>, + policy: DedupPolicy, + hash: &[i32], + ) -> Result { + let mut rows = Vec::with_capacity(per_row.len()); + let mut at = 0_usize; + for (row, entries) in per_row.into_iter().enumerate() { + let mut seen: HashMap> = HashMap::with_capacity(entries.len()); + let mut kept: Vec> = Vec::with_capacity(entries.len()); + for e in entries { + if e.keys.is_null(e.key) { + return Err(KernelError::with_row(Some(row), NullMapKey {}.into())); + } + let h = hash_at(hash, at)?; + at = at.saturating_add(1); + let mut found = None; + if let Some(same) = seen.get(&h) { + for &p in same { + if keys_equal(kept[p].keys, kept[p].key, e.keys, e.key)? { + found = Some(p); + break; + } + } + } + match found { + Some(p) => { + if policy == DedupPolicy::Exception { + return Err(KernelError::with_row( + Some(row), + duplicate_key(e.keys, e.key)?, + )); + } + kept[p].values = e.values; + kept[p].value = e.value; + } + None => { + seen.entry(h).or_default().push(kept.len()); + kept.push(e); + } + } + } + rows.push(kept); + } + Ok(Self { rows }) + } +} + +/// `DUPLICATED_MAP_KEY` for the key value, rendered as Spark renders it. +fn duplicate_key(keys: &dyn Array, key: usize) -> Result { + Ok(DuplicatedMapKey { + key: key_text(keys, key)?, + map_key_dedup_policy: "\"spark.sql.mapKeyDedupPolicy\"".to_owned(), + } + .into()) +} + +/// Spark's `key.toString` for a key value: strings as they are, numbers by +/// their display (`1.0` for floating and decimal one, `NaN` for NaN), dates +/// and timestamps by their internal number, binary by its bytes. Nested +/// keys render in brackets; only the error class is compared anywhere, so +/// this is best-effort display, not a format pin. +fn key_text(keys: &dyn Array, key: usize) -> Result { + use DataType as T; + match keys.data_type() { + T::Utf8 | T::Utf8View | T::LargeUtf8 => Ok(string_value(keys, key).to_owned()), + T::Boolean => Ok(keys.as_boolean().value(key).to_string()), + T::Int8 => Ok(keys.as_primitive::().value(key).to_string()), + T::Int16 => Ok(keys.as_primitive::().value(key).to_string()), + T::Int32 => Ok(keys.as_primitive::().value(key).to_string()), + T::Int64 => Ok(keys.as_primitive::().value(key).to_string()), + T::UInt8 => Ok(keys.as_primitive::().value(key).to_string()), + T::UInt16 => Ok(keys.as_primitive::().value(key).to_string()), + T::UInt32 => Ok(keys.as_primitive::().value(key).to_string()), + T::UInt64 => Ok(keys.as_primitive::().value(key).to_string()), + T::Float32 => { + let v = keys.as_primitive::().value(key); + if v.is_nan() { + Ok("NaN".to_owned()) + } else { + Ok(format!("{v:?}")) + } + } + T::Float64 => { + let v = keys.as_primitive::().value(key); + if v.is_nan() { + Ok("NaN".to_owned()) + } else { + Ok(format!("{v:?}")) + } + } + T::Decimal128(_, scale) => { + decimal_text(keys.as_primitive::().value(key), *scale) + } + T::Binary | T::BinaryView | T::LargeBinary => Ok(format!("{:?}", binary_value(keys, key))), + T::Date32 => Ok(keys.as_primitive::().value(key).to_string()), + T::Timestamp(..) => Ok(keys + .as_primitive::() + .value(key) + .to_string()), + T::List(_) | T::LargeList(_) => { + let (from, to) = list_range(keys, key)?; + let values = list_values(keys); + let mut parts = Vec::new(); + for p in from..to { + parts.push(if values.is_null(p) { + "null".to_owned() + } else { + key_text(values.as_ref(), p)? + }); + } + Ok(format!("[{}]", parts.join(", "))) + } + T::Struct(_) => { + let s = keys.as_struct(); + let mut parts = Vec::new(); + for col in s.columns() { + parts.push(if col.is_null(key) { + "null".to_owned() + } else { + key_text(col.as_ref(), key)? + }); + } + Ok(format!("[{}]", parts.join(", "))) + } + _ => Ok(format!("{:?}", keys)), + } +} + +/// A decimal unscaled value with `scale` digits after the point. +fn decimal_text(unscaled: i128, scale: i8) -> Result { + let scale = usize::try_from(scale.max(0)).map_err(internal)?; + let digits = unscaled.unsigned_abs().to_string(); + let padded = format!("{:0>width$}", digits, width = scale.saturating_add(1)); + let point = padded.len().saturating_sub(scale); + let (int, frac) = padded.split_at(point); + let sign = if unscaled < 0 { "-" } else { "" }; + if scale == 0 { + Ok(format!("{sign}{int}")) + } else { + Ok(format!("{sign}{int}.{frac}")) + } +} + +/// Assembles the deduplicated rows into a [`MapArray`] over `entries` (the +/// `entries` struct field of the output map type). +fn assemble( + entries: &FieldRef, + deduped: &Deduped<'_>, + nulls: Option, +) -> Result { + let fields = match entries.data_type() { + DataType::Struct(fs) if fs.len() == 2 => fs.clone(), + t => return Err(internal(format!("map entries of type {t}"))), + }; + let total: usize = deduped.rows.iter().map(Vec::len).sum(); + let mut keys = make_builder(fields[0].data_type(), total); + let mut values = make_builder(fields[1].data_type(), total); + let mut offsets = Vec::with_capacity(deduped.rows.len().saturating_add(1)); + offsets.push(0_i32); + for row in &deduped.rows { + for e in row { + append_value(keys.as_mut(), e.keys, e.key)?; + append_value(values.as_mut(), e.values, e.value)?; + } + let next = i32::try_from(keys.len()) + .map_err(|_| KernelError::out_of_memory(keys.len().saturating_mul(16)))?; + offsets.push(next); + } + let values = StructArray::try_new(fields, vec![keys.finish(), values.finish()], None) + .map_err(internal)?; + let offsets = OffsetBuffer::new(offsets.into()); + MapArray::try_new(Arc::clone(entries), offsets, values, nulls, false).map_err(internal) +} + +/// The Murmur3 hash of every key of `arrays[i]` (of `counts[i]` values), +/// concatenated: equal keys hash equally whatever array holds them. +fn hash_all(arrays: &[&dyn Array], counts: &[usize]) -> Result, KernelError> { + let mut out = Vec::new(); + for (a, n) in arrays.iter().zip(counts) { + if *n == 0 { + continue; + } + let h = hash::hash(std::slice::from_ref(a), *n)?; + out.extend(h.values().iter().copied()); + } + Ok(out) +} + +/// `map(k1, v1, ...)`: one entry per key/value column pair per row. +/// `keys[i]` pairs with `values[i]`; every column has `rows` values and all +/// keys share the Arrow type, as do all values. +pub fn create_map( + keys: &[ArrayRef], + values: &[ArrayRef], + rows: usize, + entries: &FieldRef, + policy: DedupPolicy, +) -> Result { + if keys.len() != values.len() { + return Err(internal("map keys and values of different counts")); + } + for (a, b) in keys.iter().zip(values) { + if a.len() != rows || b.len() != rows { + return Err(internal("a map column of the wrong length")); + } + } + let key_refs: Vec<&dyn Array> = keys.iter().map(AsRef::as_ref).collect(); + // Column-major hashes: pair `i`, row `r` hashed at `i * rows + r`. + let hash = hash_all(&key_refs, &vec![rows; keys.len()])?; + let mut per_row = Vec::with_capacity(rows); + let mut ordered = Vec::with_capacity(rows.saturating_mul(keys.len())); + for r in 0..rows { + let mut row = Vec::with_capacity(keys.len()); + for (i, (k, v)) in keys.iter().zip(values).enumerate() { + let at = i + .checked_mul(rows) + .and_then(|at| at.checked_add(r)) + .ok_or_else(|| internal("map entries past their hashes"))?; + ordered.push(hash_at(&hash, at)?); + row.push(Entry { + keys: k.as_ref(), + key: r, + values: v.as_ref(), + value: r, + }); + } + per_row.push(row); + } + assemble(entries, &Deduped::of(per_row, policy, &ordered)?, None) +} + +/// `map_concat(m1, ...)`: the entries of every map per row, in order. A +/// null map makes its row null, whatever the other maps hold. +pub fn concat( + maps: &[ArrayRef], + rows: usize, + entries: &FieldRef, + policy: DedupPolicy, +) -> Result { + let marrays: Vec = maps + .iter() + .map(|m| { + if m.len() != rows { + return Err(internal("a map_concat argument of the wrong length")); + } + let Some(m) = m.as_map_opt() else { + return Err(internal("a map_concat argument without map data")); + }; + Ok(m.clone()) + }) + .collect::>()?; + let key_refs: Vec<&dyn Array> = marrays.iter().map(|m| m.keys().as_ref()).collect(); + let counts: Vec = marrays.iter().map(|m| m.keys().len()).collect(); + let hash = hash_all(&key_refs, &counts)?; + // The whole-array hash of map `mi` starts at `base[mi]`. + let mut base = Vec::with_capacity(marrays.len()); + let mut len = 0_usize; + for n in &counts { + base.push(len); + len = len.saturating_add(*n); + } + let mut nulls = NullBufferBuilder::new(rows); + let mut per_row = Vec::with_capacity(rows); + let mut ordered = Vec::new(); + for r in 0..rows { + if marrays.iter().any(|m| m.is_null(r)) { + nulls.append(false); + per_row.push(Vec::new()); + continue; + } + nulls.append(true); + let mut row = Vec::new(); + for (mi, m) in marrays.iter().enumerate() { + let (from, to) = map_range(m, r)?; + for p in from..to { + let base_at = base + .get(mi) + .copied() + .ok_or_else(|| internal("map entries past their hashes"))?; + let h = hash_at(&hash, base_at.saturating_add(p))?; + ordered.push(h); + row.push(Entry { + keys: m.keys().as_ref(), + key: p, + values: m.values().as_ref(), + value: p, + }); + } + } + per_row.push(row); + } + assemble( + entries, + &Deduped::of(per_row, policy, &ordered)?, + nulls.finish(), + ) +} + +/// `map_contains_key(map, key)`: whether the key occurs in each row's map +/// (a linear scan, as Spark's `ArrayContains` does). A null map or a null +/// key is null. +pub fn contains_key(map: &ArrayRef, key: &ArrayRef) -> Result { + let rows = map.len(); + if key.len() != rows { + return Err(internal("map_contains_key arguments of different lengths")); + } + let Some(m) = map.as_map_opt() else { + return Err(internal("a map function over non-map data")); + }; + let mut out = BooleanArray::builder(rows); + for r in 0..rows { + if m.is_null(r) || key.is_null(r) { + out.append_null(); + continue; + } + let (from, to) = map_range(m, r)?; + let mut found = false; + for p in from..to { + if keys_equal(m.keys().as_ref(), p, key.as_ref(), r)? { + found = true; + break; + } + } + out.append_value(found); + } + Ok(out.finish()) +} + +/// `map_keys` / `map_values`: the key or value slice of every row, sharing +/// the map's children and offsets (a null map stays null). +fn project(m: &MapArray, child: &ArrayRef, element: &FieldRef) -> Result { + Ok(Arc::new(ListArray::new( + Arc::clone(element), + m.offsets().clone(), + Arc::clone(child), + m.nulls().cloned(), + ))) +} + +/// `map_keys(map)`. +pub fn keys(map: &ArrayRef, element: &FieldRef) -> Result { + let Some(m) = map.as_map_opt() else { + return Err(internal("a map function over non-map data")); + }; + project(m, m.keys(), element) +} + +/// `map_values(map)`. +pub fn values(map: &ArrayRef, element: &FieldRef) -> Result { + let Some(m) = map.as_map_opt() else { + return Err(internal("a map function over non-map data")); + }; + project(m, m.values(), element) +} + +/// `map_entries(map)`: one `{key, value}` struct per entry, over the shared +/// children (a null map stays null). +pub fn entries(map: &ArrayRef, element: &FieldRef) -> Result { + let Some(m) = map.as_map_opt() else { + return Err(internal("a map function over non-map data")); + }; + let fields = match element.data_type() { + DataType::Struct(fs) => fs.clone(), + t => return Err(internal(format!("map entries of type {t}"))), + }; + let structs = StructArray::try_new( + fields, + vec![Arc::clone(m.keys()), Arc::clone(m.values())], + None, + ) + .map_err(internal)?; + Ok(Arc::new(ListArray::new( + Arc::clone(element), + m.offsets().clone(), + Arc::new(structs), + m.nulls().cloned(), + ))) +} + +/// The list rows of `a` (a `List` of `rows` rows) as child ranges. +fn list_rows(a: &GenericListArray, rows: usize) -> Result, KernelError> { + if a.len() != rows { + return Err(internal("a map input of the wrong length")); + } + (0..rows) + .map(|r| { + if a.is_null(r) { + Ok(None) + } else { + let (Some(from), Some(to)) = ( + a.value_offsets().get(r), + a.value_offsets().get(r.saturating_add(1)), + ) else { + return Err(internal("a list row past its offsets")); + }; + Ok(Some((from.as_usize(), to.as_usize()))) + } + }) + .collect::, _>>() + .map(|v| v.into_iter().map(|o| o.unwrap_or((0, 0))).collect()) +} + +/// `map_from_arrays(keys, values)`: row `r` maps the `r`-th key slice to +/// the `r`-th value slice. Slices of different lengths are +/// `_LEGACY_ERROR_TEMP_2128`; a null slice makes its row null. +pub fn from_arrays( + keys: &ArrayRef, + values: &ArrayRef, + rows: usize, + entries: &FieldRef, + policy: DedupPolicy, +) -> Result { + let (k, v) = match (keys.data_type(), values.data_type()) { + (DataType::List(_), DataType::List(_)) => (keys.as_list::(), values.as_list::()), + (x, y) => return Err(internal(format!("map_from_arrays over {x} and {y}"))), + }; + let (kr, vr) = (list_rows(k, rows)?, list_rows(v, rows)?); + let hash = hash_all(&[k.values().as_ref()], &[k.values().len()])?; + let mut nulls = NullBufferBuilder::new(rows); + let mut per_row = Vec::with_capacity(rows); + let mut ordered = Vec::new(); + for r in 0..rows { + if k.is_null(r) || v.is_null(r) { + nulls.append(false); + per_row.push(Vec::new()); + continue; + } + nulls.append(true); + let ((kf, kt), (vf, vt)) = (kr[r], vr[r]); + if kt.saturating_sub(kf) != vt.saturating_sub(vf) { + return Err(KernelError::with_row( + Some(r), + LegacyErrorTemp2128 {}.into(), + )); + } + let mut row = Vec::with_capacity(kt.saturating_sub(kf)); + for (p, q) in (kf..kt).zip(vf..vt) { + ordered.push(hash_at(&hash, p)?); + row.push(Entry { + keys: k.values().as_ref(), + key: p, + values: v.values().as_ref(), + value: q, + }); + } + per_row.push(row); + } + assemble( + entries, + &Deduped::of(per_row, policy, &ordered)?, + nulls.finish(), + ) +} + +/// `map_from_entries(entries)`: row `r` maps the `r`-th struct slice's +/// first field to its second. A null element (of a nullable array) makes +/// only its own row null; a null key field is `NULL_MAP_KEY`. +pub fn from_entries( + array: &ArrayRef, + rows: usize, + entries: &FieldRef, + policy: DedupPolicy, +) -> Result { + let list = match array.data_type() { + DataType::List(_) => array.as_list::(), + t => return Err(internal(format!("map_from_entries over {t}"))), + }; + let (keys, values) = match list.values().data_type() { + DataType::Struct(fs) if fs.len() == 2 => { + let s = list.values().as_struct(); + (Arc::clone(&s.columns()[0]), Arc::clone(&s.columns()[1])) + } + t => return Err(internal(format!("map_from_entries over entries of {t}"))), + }; + let ranges = list_rows(list, rows)?; + let hash = hash_all(&[keys.as_ref()], &[keys.len()])?; + let mut nulls = NullBufferBuilder::new(rows); + let mut per_row = Vec::with_capacity(rows); + let mut ordered = Vec::new(); + for (r, range) in ranges.iter().enumerate() { + if list.is_null(r) { + nulls.append(false); + per_row.push(Vec::new()); + continue; + } + let (from, to) = *range; + let base = ordered.len(); + let mut row = Vec::with_capacity(to.saturating_sub(from)); + let mut null_element = false; + for p in from..to { + if list.values().is_null(p) { + null_element = true; + break; + } + ordered.push(hash_at(&hash, p)?); + row.push(Entry { + keys: keys.as_ref(), + key: p, + values: values.as_ref(), + value: p, + }); + } + if null_element { + // A null element of a nullable array nulls only its own row. + ordered.truncate(base); + nulls.append(false); + per_row.push(Vec::new()); + continue; + } + nulls.append(true); + per_row.push(row); + } + assemble( + entries, + &Deduped::of(per_row, policy, &ordered)?, + nulls.finish(), + ) +} + +/// `str_to_map` assembly: `keys` and `values` hold every row's pairs in +/// row-major order (`row_of[p]` is pair `p`'s row). A row with no pair had +/// a null text or delimiter and is null; any other row keeps its pairs, +/// even when there is only one. +pub fn from_pairs( + keys: &ArrayRef, + values: &ArrayRef, + row_of: &[usize], + rows: usize, + entries: &FieldRef, + policy: DedupPolicy, +) -> Result { + if keys.len() != values.len() || keys.len() != row_of.len() { + return Err(internal("str_to_map pairs of different lengths")); + } + let hash = hash_all(&[keys.as_ref()], &[keys.len()])?; + let mut nulls = NullBufferBuilder::new(rows); + let mut per_row: Vec>> = (0..rows).map(|_| Vec::new()).collect(); + let mut ordered = Vec::with_capacity(row_of.len()); + for (p, r) in row_of.iter().enumerate() { + let Some(row) = per_row.get_mut(*r) else { + return Err(internal("a str_to_map pair past its rows")); + }; + ordered.push(hash_at(&hash, p)?); + row.push(Entry { + keys: keys.as_ref(), + key: p, + values: values.as_ref(), + value: p, + }); + } + for row in &per_row { + nulls.append(!row.is_empty()); + } + assemble( + entries, + &Deduped::of(per_row, policy, &ordered)?, + nulls.finish(), + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use arrow_array::{Decimal128Array, Int32Array, StringArray, StringViewArray}; + use arrow_buffer::NullBufferBuilder; + use arrow_schema::Field; + use krishiv_common::error::ErrorClass; + + fn test_entries(key: DataType, value: DataType, value_nullable: bool) -> FieldRef { + let entries = DataType::Struct( + vec![ + Field::new("key", key, false), + Field::new("value", value, value_nullable), + ] + .into(), + ); + Arc::new(Field::new("entries", entries, false)) + } + + fn strings(v: &[Option<&str>]) -> ArrayRef { + Arc::new(StringArray::from(v.to_vec())) + } + + fn views(v: &[Option<&str>]) -> ArrayRef { + Arc::new(StringViewArray::from( + v.iter().map(|s| s.as_deref()).collect::>(), + )) + } + + fn ints(v: &[Option]) -> ArrayRef { + Arc::new(Int32Array::from(v.to_vec())) + } + + fn int_field_entries() -> FieldRef { + test_entries(DataType::Int32, DataType::Utf8View, true) + } + + type Pairs = Vec)>>>; + + /// The `(key, value)` pairs of every map row, rendered for assertions. + fn pairs(m: &MapArray) -> Pairs { + (0..m.len()) + .map(|r| { + if m.is_null(r) { + return None; + } + let (from, to) = map_range(m, r).unwrap(); + let mut row = Vec::new(); + for p in from..to { + let k = key_text(m.keys().as_ref(), p).expect("key text renders"); + let v = if m.values().is_null(p) { + None + } else { + Some(string_value(m.values().as_ref(), p).to_owned()) + }; + row.push((k, v)); + } + Some(row) + }) + .collect() + } + + /// A `MapArray` input over `entries`, with `counts[r]` entries in row + /// `r` (`null_rows[r]` is null). + fn map_input( + keys: ArrayRef, + values: ArrayRef, + entries: &FieldRef, + counts: &[usize], + null_rows: &[bool], + ) -> MapArray { + let mut offsets = vec![0_i32]; + for (n, null) in counts.iter().zip(null_rows) { + let next = if *null { + offsets.last().copied().unwrap_or(0) + } else { + offsets + .last() + .copied() + .unwrap_or(0) + .saturating_add(i32::try_from(*n).unwrap_or(0)) + }; + offsets.push(next); + } + let fields = match entries.data_type() { + DataType::Struct(fs) => fs.clone(), + _ => unreachable!(), + }; + let structs = StructArray::try_new(fields, vec![keys, values], None).unwrap(); + let mut nulls = NullBufferBuilder::new(counts.len()); + for null in null_rows { + nulls.append(!null); + } + MapArray::try_new( + Arc::clone(entries), + OffsetBuffer::new(offsets.into()), + structs, + nulls.finish(), + false, + ) + .unwrap() + } + + fn list_of(values: ArrayRef, breaks: &[usize], nulls: &[bool]) -> ArrayRef { + let mut offsets = vec![0_i32]; + for (n, null) in breaks.iter().zip(nulls) { + let next = if *null { + offsets.last().copied().unwrap_or(0) + } else { + offsets + .last() + .copied() + .unwrap_or(0) + .saturating_add(i32::try_from(*n).unwrap_or(0)) + }; + offsets.push(next); + } + let mut valid = NullBufferBuilder::new(breaks.len()); + for null in nulls { + valid.append(!null); + } + Arc::new(ListArray::new( + Arc::new(Field::new("item", values.data_type().clone(), true)), + OffsetBuffer::new(offsets.into()), + values, + valid.finish(), + )) + } + + #[test] + fn equal_keys_cover_every_carrier() { + assert!(keys_equal(&ints(&[Some(1)]), 0, &ints(&[Some(1)]), 0).unwrap()); + assert!(!keys_equal(&ints(&[Some(1)]), 0, &ints(&[Some(2)]), 0).unwrap()); + // A null equals only a null. + assert!(keys_equal(&ints(&[None]), 0, &ints(&[None]), 0).unwrap()); + assert!(!keys_equal(&ints(&[None]), 0, &ints(&[Some(1)]), 0).unwrap()); + // Strings compare byte-wise across carriers. + assert!(keys_equal(&strings(&[Some("a")]), 0, &views(&[Some("a")]), 0).unwrap()); + assert!(!keys_equal(&strings(&[Some("a")]), 0, &views(&[Some("b")]), 0).unwrap()); + // Floats: NaN equals NaN, -0.0 equals 0.0. + let nan = Arc::new(arrow_array::Float64Array::from(vec![f64::NAN])) as ArrayRef; + assert!(keys_equal(nan.as_ref(), 0, nan.as_ref(), 0).unwrap()); + let (neg, pos) = ( + Arc::new(arrow_array::Float64Array::from(vec![-0.0])) as ArrayRef, + Arc::new(arrow_array::Float64Array::from(vec![0.0])) as ArrayRef, + ); + assert!(keys_equal(neg.as_ref(), 0, pos.as_ref(), 0).unwrap()); + // Decimals compare by unscaled value. + let dec = |u: i128| { + Arc::new( + Decimal128Array::from(vec![u]) + .with_precision_and_scale(10, 2) + .unwrap(), + ) as ArrayRef + }; + assert!(keys_equal(&dec(100), 0, &dec(100), 0).unwrap()); + assert!(!keys_equal(&dec(100), 0, &dec(101), 0).unwrap()); + // Nested values compare element by element. + let l1 = list_of(ints(&[Some(1), None]), &[2], &[false]); + let l2 = list_of(ints(&[Some(1), None]), &[2], &[false]); + let l3 = list_of(ints(&[Some(1), Some(2)]), &[2], &[false]); + assert!(keys_equal(l1.as_ref(), 0, l2.as_ref(), 0).unwrap()); + assert!(!keys_equal(l1.as_ref(), 0, l3.as_ref(), 0).unwrap()); + // Types that cannot meet are an internal error, not a panic. + assert!(keys_equal(&ints(&[Some(1)]), 0, &strings(&[Some("1")]), 0).is_err()); + } + + #[test] + fn create_map_builds_a_map_per_row() { + let keys = [ints(&[Some(1), Some(3)]), ints(&[Some(2), Some(4)])]; + let values = [ + strings(&[Some("a"), None]), + strings(&[Some("b"), Some("d")]), + ]; + let m = create_map( + &keys, + &values, + 2, + &int_field_entries(), + DedupPolicy::Exception, + ) + .unwrap(); + assert_eq!( + pairs(&m), + [ + Some(vec![ + ("1".to_owned(), Some("a".to_owned())), + ("2".to_owned(), Some("b".to_owned())), + ]), + Some(vec![ + ("3".to_owned(), None), + ("4".to_owned(), Some("d".to_owned())), + ]), + ] + ); + // The output carries the entries field: struct `key` (not null) and + // `value`, over `Utf8View` values. + assert_eq!(m.data_type(), &DataType::Map(int_field_entries(), false)); + assert_eq!(m.value_offsets().len(), 3); + } + + #[test] + fn create_map_rejects_null_and_duplicate_keys() { + let keys = [ints(&[Some(1), None])]; + let values = [strings(&[Some("a"), Some("b")])]; + let e = create_map( + &keys, + &values, + 2, + &int_field_entries(), + DedupPolicy::Exception, + ) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::NullMapKey); + assert_eq!(e.row(), Some(1)); + + let keys = [ints(&[Some(1)]), ints(&[Some(1)])]; + let values = [strings(&[Some("a")]), strings(&[Some("b")])]; + let e = create_map( + &keys, + &values, + 1, + &int_field_entries(), + DedupPolicy::Exception, + ) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::DuplicatedMapKey); + assert_eq!(e.row(), Some(0)); + assert!( + e.error() + .message() + .contains("Duplicate map key 1 was found") + ); + let params: Vec<(&str, String)> = e + .error() + .message_parameters() + .iter() + .map(|(k, v)| (*k, v.clone())) + .collect(); + assert!(params.contains(&("key", "1".to_owned()))); + assert!(params.contains(&( + "mapKeyDedupPolicy", + "\"spark.sql.mapKeyDedupPolicy\"".to_owned() + ))); + + // `LAST_WIN` keeps the first position with the last value. + let m = create_map( + &keys, + &values, + 1, + &int_field_entries(), + DedupPolicy::LastWin, + ) + .unwrap(); + assert_eq!( + pairs(&m), + [Some(vec![("1".to_owned(), Some("b".to_owned()))])] + ); + } + + #[test] + fn create_map_empty_is_an_empty_map_per_row() { + let m = create_map(&[], &[], 2, &int_field_entries(), DedupPolicy::Exception).unwrap(); + assert_eq!(pairs(&m), [Some(vec![]), Some(vec![])]); + } + + #[test] + fn create_map_hashes_align_with_rows() { + // The dedup hash of pair `i`, row `r` is read row-major: a repeat + // in a later row is still found (a column-major read would miss + // it, as the hashes differ). + let keys = [ints(&[Some(1), Some(1)]), ints(&[Some(2), Some(1)])]; + let values = [ + strings(&[Some("a"), Some("b")]), + strings(&[Some("c"), Some("d")]), + ]; + let e = create_map( + &keys, + &values, + 2, + &int_field_entries(), + DedupPolicy::Exception, + ) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::DuplicatedMapKey); + assert_eq!(e.row(), Some(1)); + } + + #[test] + fn create_map_nests_arrays_structs_and_maps() { + // Array keys. + let k1 = list_of(ints(&[Some(1), Some(2)]), &[2], &[false]); + let k2 = list_of(ints(&[Some(1), Some(2)]), &[2], &[false]); + let v = [strings(&[Some("a")]), strings(&[Some("b")])]; + let e = create_map( + &[Arc::clone(&k1), Arc::clone(&k2)], + &v, + 1, + &test_entries( + DataType::List(Arc::new(Field::new("element", DataType::Int32, true))), + DataType::Utf8View, + true, + ), + DedupPolicy::Exception, + ) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::DuplicatedMapKey); + + // Map values. + let inner = create_map( + &[ints(&[Some(7)])], + &[strings(&[Some("x")])], + 1, + &int_field_entries(), + DedupPolicy::Exception, + ) + .unwrap(); + let m = create_map( + &[strings(&[Some("m")])], + &[Arc::new(inner) as ArrayRef], + 1, + &test_entries( + DataType::Utf8View, + DataType::Map(int_field_entries(), false), + false, + ), + DedupPolicy::Exception, + ) + .unwrap(); + assert_eq!(m.len(), 1); + assert!(!m.is_null(0)); + let (from, to) = map_range(&m, 0).unwrap(); + assert_eq!((to - from), 1); + } + + #[test] + fn create_map_scales_to_thousands_of_rows() { + let rows = 2_000_usize; + let keys = [Arc::new(Int32Array::from_iter_values( + 0..i32::try_from(rows).unwrap_or(0), + )) as ArrayRef]; + let values = [strings(&vec![Some("v"); rows])]; + let m = create_map( + &keys, + &values, + rows, + &int_field_entries(), + DedupPolicy::Exception, + ) + .unwrap(); + assert_eq!(m.len(), rows); + assert_eq!( + m.value_offsets().last().copied().unwrap_or(0), + i32::try_from(rows).unwrap_or(-1) + ); + let (from, to) = map_range(&m, rows - 1).unwrap(); + assert_eq!((to - from), 1); + assert_eq!( + key_text(m.keys().as_ref(), from).expect("key text renders"), + (i32::try_from(rows).unwrap_or(0).saturating_sub(1)).to_string() + ); + } + + #[test] + fn concat_merges_with_nulls_and_policy() { + let entries = int_field_entries(); + let left = map_input( + ints(&[Some(1)]), + views(&[Some("a")]), + &entries, + &[1], + &[false], + ); + let right = Arc::new(map_input( + ints(&[Some(1)]), + views(&[Some("B")]), + &entries, + &[1], + &[false], + )) as ArrayRef; + // Key 1 in both maps is a duplicate under `EXCEPTION`. + let e = concat( + &[Arc::new(left.clone()) as ArrayRef, Arc::clone(&right)], + 1, + &entries, + DedupPolicy::Exception, + ) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::DuplicatedMapKey); + assert_eq!(e.row(), Some(0)); + + // Under `LAST_WIN` the later map's value wins in place. + let m = concat( + &[Arc::new(left.clone()) as ArrayRef, Arc::clone(&right)], + 1, + &entries, + DedupPolicy::LastWin, + ) + .unwrap(); + assert_eq!( + pairs(&m), + [Some(vec![("1".to_owned(), Some("B".to_owned()))])] + ); + let _ = right; + + // Disjoint maps merge; a null map voids its row under either + // policy, whatever the other maps hold. + let other = Arc::new(map_input( + ints(&[Some(2)]), + views(&[Some("b")]), + &entries, + &[1], + &[false], + )) as ArrayRef; + let m = concat( + &[Arc::new(left) as ArrayRef, Arc::clone(&other)], + 1, + &entries, + DedupPolicy::Exception, + ) + .unwrap(); + assert_eq!( + pairs(&m), + [Some(vec![ + ("1".to_owned(), Some("a".to_owned())), + ("2".to_owned(), Some("b".to_owned())), + ])] + ); + + let void = Arc::new(map_input(ints(&[]), views(&[]), &entries, &[0], &[true])) as ArrayRef; + for policy in [DedupPolicy::Exception, DedupPolicy::LastWin] { + let m = concat( + &[Arc::clone(&void), Arc::clone(&other)], + 1, + &entries, + policy, + ) + .unwrap(); + assert_eq!(pairs(&m), [None]); + } + + // No maps is an empty map per row. + let m = concat(&[], 2, &entries, DedupPolicy::Exception).unwrap(); + assert_eq!(pairs(&m), [Some(vec![]), Some(vec![])]); + } + + #[test] + fn contains_key_scans_with_nulls() { + let entries = int_field_entries(); + let map = map_input( + ints(&[Some(1), Some(2), Some(0)]), + views(&[Some("a"), Some("b"), Some("c")]), + &entries, + &[2, 0, 0], + &[false, false, true], + ); + let out = contains_key( + &(Arc::new(map) as ArrayRef), + &ints(&[Some(2), Some(1), None]), + ) + .unwrap(); + assert_eq!(out, BooleanArray::from(vec![Some(true), Some(false), None])); + } + + #[test] + fn contains_key_normalises_floats() { + // `-0.0` finds `0.0`, NaN finds NaN: Spark's key equality. + let entries = test_entries(DataType::Float64, DataType::Utf8View, true); + let map = map_input( + Arc::new(arrow_array::Float64Array::from(vec![Some(0.0)])) as ArrayRef, + views(&[Some("zero")]), + &entries, + &[1], + &[false], + ); + let out = contains_key( + &(Arc::new(map) as ArrayRef), + &(Arc::new(arrow_array::Float64Array::from(vec![Some(-0.0)])) as ArrayRef), + ) + .unwrap(); + assert_eq!(out, BooleanArray::from(vec![Some(true)])); + } + + #[test] + fn projections_share_children() { + let map_field = test_entries(DataType::Int32, DataType::Utf8View, true); + let map = map_input( + ints(&[Some(1), Some(2)]), + views(&[Some("a"), None]), + &map_field, + &[2, 0], + &[false, true], + ); + let map = Arc::new(map) as ArrayRef; + let key_field = Arc::new(Field::new("element", DataType::Int32, true)); + let k = keys(&map, &key_field).unwrap(); + let l = k.as_list::(); + assert_eq!(l.len(), 2); + assert!(l.is_null(1)); + assert_eq!(l.value_offsets(), &[0_i32, 2, 2][..]); + + let value_field = Arc::new(Field::new("element", DataType::Utf8View, true)); + let v = values(&map, &value_field).unwrap(); + assert_eq!(v.len(), 2); + + let entry_field = Arc::new(Field::new( + "element", + DataType::Struct( + vec![ + Field::new("key", DataType::Int32, false), + Field::new("value", DataType::Utf8View, true), + ] + .into(), + ), + false, + )); + let e = entries(&map, &entry_field).unwrap(); + let l = e.as_list::(); + assert_eq!(l.len(), 2); + let s = l.values().as_struct(); + assert_eq!(s.num_columns(), 2); + assert_eq!(s.column(0).len(), 2); + } + + #[test] + fn from_arrays_maps_slices_with_policy() { + let entries = test_entries(DataType::Decimal128(10, 2), DataType::Utf8View, true); + let key_values = Arc::new( + Decimal128Array::from(vec![Some(100), Some(200), Some(300)]) + .with_precision_and_scale(10, 2) + .unwrap(), + ) as ArrayRef; + let keys = list_of(key_values, &[2, 1, 0], &[false, false, true]); + let values = list_of( + strings(&[Some("a"), Some("b"), Some("c")]), + &[2, 1, 0], + &[false, false, true], + ); + let m = from_arrays(&keys, &values, 3, &entries, DedupPolicy::Exception).unwrap(); + assert_eq!(m.len(), 3); + assert!(m.is_null(2)); + let (from, to) = map_range(&m, 0).unwrap(); + assert_eq!((to - from), 2); + + // Different slice lengths are `_LEGACY_ERROR_TEMP_2128`. + let keys = list_of(ints(&[Some(1)]), &[1], &[false]); + let values = list_of(strings(&[Some("a"), Some("b")]), &[2], &[false]); + let e = from_arrays( + &keys, + &values, + 1, + &int_field_entries(), + DedupPolicy::Exception, + ) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::LegacyErrorTemp2128); + assert_eq!(e.row(), Some(0)); + + // A null key element is `NULL_MAP_KEY`, wherever it sits. + let keys = list_of(ints(&[Some(1), None]), &[2], &[false]); + let values = list_of(strings(&[Some("a"), Some("b")]), &[2], &[false]); + let e = from_arrays( + &keys, + &values, + 1, + &int_field_entries(), + DedupPolicy::Exception, + ) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::NullMapKey); + + // Duplicate keys follow the policy. + let keys = list_of(ints(&[Some(1), Some(1)]), &[2], &[false]); + let values = list_of(strings(&[Some("a"), Some("b")]), &[2], &[false]); + let e = from_arrays( + &keys, + &values, + 1, + &int_field_entries(), + DedupPolicy::Exception, + ) + .unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::DuplicatedMapKey); + let m = from_arrays( + &keys, + &values, + 1, + &int_field_entries(), + DedupPolicy::LastWin, + ) + .unwrap(); + assert_eq!( + pairs(&m), + [Some(vec![("1".to_owned(), Some("b".to_owned()))])] + ); + } + + #[test] + fn null_struct_values_append_typed_nulls() { + let struct_ty = DataType::Struct(vec![Field::new("a", DataType::Int32, true)].into()); + let struct_fields = match &struct_ty { + DataType::Struct(fs) => fs.clone(), + _ => unreachable!(), + }; + // A null struct as a map value: the map holds a null. + let null_struct = Arc::new( + StructArray::try_new( + struct_fields.clone(), + vec![ints(&[Some(1)])], + Some(arrow_buffer::NullBuffer::from(vec![false])), + ) + .unwrap(), + ) as ArrayRef; + let entries = test_entries(DataType::Int32, struct_ty.clone(), true); + let m = create_map( + &[ints(&[Some(1)])], + &[null_struct], + 1, + &entries, + DedupPolicy::Exception, + ) + .unwrap(); + assert!(!m.is_null(0)); + assert!(m.values().is_null(0)); + + // A null struct element of a list value: the list keeps a null. + let inner = Arc::new( + StructArray::try_new( + struct_fields, + vec![ints(&[Some(1), Some(2)])], + Some(arrow_buffer::NullBuffer::from(vec![true, false])), + ) + .unwrap(), + ) as ArrayRef; + let list_value = list_of(inner, &[2], &[false]); + let list_ty = DataType::List(Arc::new(Field::new("element", struct_ty, true))); + let entries = test_entries(DataType::Int32, list_ty, true); + let m = create_map( + &[ints(&[Some(1)])], + &[list_value], + 1, + &entries, + DedupPolicy::Exception, + ) + .unwrap(); + assert!(!m.is_null(0)); + let lists = m.values().as_list::(); + assert!(!lists.is_null(0)); + assert!(lists.values().as_struct().is_null(1)); + } + + #[test] + fn from_entries_maps_struct_slices() { + let fields: arrow_schema::Fields = vec![ + Field::new("key", DataType::Int32, true), + Field::new("value", DataType::Utf8View, true), + ] + .into(); + let structs = Arc::new( + StructArray::try_new( + fields.clone(), + vec![ints(&[Some(1), Some(2)]), views(&[Some("a"), Some("b")])], + None, + ) + .unwrap(), + ) as ArrayRef; + let array = list_of(structs, &[2, 0], &[false, true]); + let entries = test_entries(DataType::Int32, DataType::Utf8View, true); + let m = from_entries(&array, 2, &entries, DedupPolicy::Exception).unwrap(); + assert_eq!(m.len(), 2); + assert!(m.is_null(1)); + + // A null element nulls only its own row. + let values = Arc::new( + StructArray::try_new( + fields.clone(), + vec![ints(&[Some(9)]), views(&[Some("z")])], + Some(arrow_buffer::NullBuffer::from(vec![false])), + ) + .unwrap(), + ) as ArrayRef; + let array = list_of(values, &[1, 0], &[false, false]); + let m = from_entries(&array, 2, &entries, DedupPolicy::Exception).unwrap(); + assert!(m.is_null(0)); + assert!(!m.is_null(1)); + assert_eq!(pairs(&m), [None, Some(vec![])]); + + // A null key field is `NULL_MAP_KEY`. + let structs = Arc::new( + StructArray::try_new(fields, vec![ints(&[None]), views(&[Some("a")])], None).unwrap(), + ) as ArrayRef; + let array = list_of(structs, &[1], &[false]); + let e = from_entries(&array, 1, &entries, DedupPolicy::Exception).unwrap_err(); + assert_eq!(e.error_class(), ErrorClass::NullMapKey); + + // Entries that are not two-field structs are refused. + let bad = list_of(ints(&[Some(1)]), &[1], &[false]); + assert!(from_entries(&bad, 1, &entries, DedupPolicy::Exception).is_err()); + } + + #[test] + fn from_pairs_rows_empty_and_null() { + let entries = test_entries(DataType::Utf8View, DataType::Utf8View, true); + let m = from_pairs( + &strings(&[Some("a"), Some("b"), Some("c")]), + &strings(&[Some("1"), None, Some("3")]), + &[0, 0, 2], + 3, + &entries, + DedupPolicy::Exception, + ) + .unwrap(); + assert_eq!( + pairs(&m), + [ + Some(vec![ + ("a".to_owned(), Some("1".to_owned())), + ("b".to_owned(), None), + ]), + None, + Some(vec![("c".to_owned(), Some("3".to_owned()))]), + ] + ); + } + + #[test] + fn policy_parses_and_shapes_hold() { + assert_eq!(DedupPolicy::of(None), DedupPolicy::Exception); + assert_eq!(DedupPolicy::of(Some("EXCEPTION")), DedupPolicy::Exception); + assert_eq!(DedupPolicy::of(Some("LAST_WIN")), DedupPolicy::LastWin); + assert_eq!(DedupPolicy::of(Some("other")), DedupPolicy::Exception); + // Every key type the analyzer can produce is supported. + for t in [ + DataType::Boolean, + DataType::Int32, + DataType::Float64, + DataType::Decimal128(10, 2), + DataType::Utf8View, + DataType::BinaryView, + DataType::Date32, + DataType::Timestamp(TimeUnit::Microsecond, None), + DataType::List(Arc::new(Field::new("element", DataType::Int32, true))), + ] { + assert!(supports_key(&t), "{t}"); + assert!(supports_value(&t), "{t}"); + } + assert!(supports_value(&DataType::Map(int_field_entries(), false))); + assert!(!supports_key(&DataType::Map(int_field_entries(), false))); + assert!(!supports_key(&DataType::Dictionary( + Box::new(DataType::Int32), + Box::new(DataType::Utf8View), + ))); + } + + #[test] + fn decimal_text_renders() { + assert_eq!(decimal_text(100, 2).expect("decimal text"), "1.00"); + assert_eq!(decimal_text(-5, 3).expect("decimal text"), "-0.005"); + assert_eq!(decimal_text(0, 0).expect("decimal text"), "0"); + assert_eq!(decimal_text(12345, 0).expect("decimal text"), "12345"); + } + + #[test] + fn large_list_keys_compare() { + use arrow_array::builder::{Int32Builder, LargeListBuilder}; + let mut a = LargeListBuilder::new(Int32Builder::new()); + a.values().append_value(1); + a.append(true); + let mut b = LargeListBuilder::new(Int32Builder::new()); + b.values().append_value(1); + b.append(true); + let (x, y) = (a.finish(), b.finish()); + assert!(keys_equal(&x, 0, &y, 0).unwrap()); + let m = create_map( + &[Arc::new(x) as ArrayRef], + &[strings(&[Some("a")])], + 1, + &test_entries( + DataType::LargeList(Arc::new(Field::new("element", DataType::Int32, true))), + DataType::Utf8View, + true, + ), + DedupPolicy::Exception, + ) + .unwrap(); + assert_eq!(m.len(), 1); + } + + #[test] + fn equal_keys_cover_every_primitive_and_struct_carrier() { + use arrow_array::{ + BinaryArray, BooleanArray, Date32Array, Float32Array, Int8Array, Int16Array, + Int64Array, NullArray, StructArray, TimestampMicrosecondArray, UInt8Array, UInt16Array, + UInt32Array, UInt64Array, + }; + // Each pair: (a, b) where row 0 of `a` equals row 0 of `b` and row 1 differs. + let pairs: Vec<(ArrayRef, ArrayRef)> = vec![ + ( + Arc::new(BooleanArray::from(vec![true, false])), + Arc::new(BooleanArray::from(vec![true, true])), + ), + ( + Arc::new(Int8Array::from(vec![1, 2])), + Arc::new(Int8Array::from(vec![1, 3])), + ), + ( + Arc::new(Int16Array::from(vec![1, 2])), + Arc::new(Int16Array::from(vec![1, 3])), + ), + ( + Arc::new(Int64Array::from(vec![1, 2])), + Arc::new(Int64Array::from(vec![1, 3])), + ), + ( + Arc::new(UInt8Array::from(vec![1, 2])), + Arc::new(UInt8Array::from(vec![1, 3])), + ), + ( + Arc::new(UInt16Array::from(vec![1, 2])), + Arc::new(UInt16Array::from(vec![1, 3])), + ), + ( + Arc::new(UInt32Array::from(vec![1, 2])), + Arc::new(UInt32Array::from(vec![1, 3])), + ), + ( + Arc::new(UInt64Array::from(vec![1, 2])), + Arc::new(UInt64Array::from(vec![1, 3])), + ), + ( + Arc::new(Float32Array::from(vec![1.5, 2.5])), + Arc::new(Float32Array::from(vec![1.5, 3.5])), + ), + ( + Arc::new(Date32Array::from(vec![1, 2])), + Arc::new(Date32Array::from(vec![1, 3])), + ), + ( + Arc::new(TimestampMicrosecondArray::from(vec![1, 2])), + Arc::new(TimestampMicrosecondArray::from(vec![1, 3])), + ), + ( + Arc::new(BinaryArray::from(vec![&b"a"[..], &b"b"[..]])), + Arc::new(BinaryArray::from(vec![&b"a"[..], &b"c"[..]])), + ), + ]; + for (a, b) in &pairs { + assert!( + keys_equal(a.as_ref(), 0, b.as_ref(), 0).unwrap(), + "{:?}", + a.data_type() + ); + assert!( + !keys_equal(a.as_ref(), 1, b.as_ref(), 1).unwrap(), + "{:?}", + a.data_type() + ); + } + let n = NullArray::new(1); + assert!(keys_equal(&n, 0, &n, 0).unwrap()); + // Structs compare field by field, by position. + let st = |x: Vec, y: Vec<&str>| -> ArrayRef { + Arc::new(StructArray::from(vec![ + ( + Arc::new(Field::new("x", DataType::Int32, true)), + Arc::new(Int32Array::from(x)) as ArrayRef, + ), + ( + Arc::new(Field::new("y", DataType::Utf8, true)), + Arc::new(StringArray::from(y)) as ArrayRef, + ), + ])) + }; + let (s1, s2) = ( + st(vec![1, 2], vec!["a", "b"]), + st(vec![1, 2], vec!["a", "c"]), + ); + assert!(keys_equal(s1.as_ref(), 0, s2.as_ref(), 0).unwrap()); + assert!(!keys_equal(s1.as_ref(), 1, s2.as_ref(), 1).unwrap()); + // Structs of different arity are never equal; fields pair by position. + let narrow: ArrayRef = Arc::new(StructArray::from(vec![( + Arc::new(Field::new("x", DataType::Int32, true)), + Arc::new(Int32Array::from(vec![1, 2])) as ArrayRef, + )])); + assert!(!keys_equal(s1.as_ref(), 0, narrow.as_ref(), 0).unwrap()); + let renamed: ArrayRef = Arc::new(StructArray::from(vec![ + ( + Arc::new(Field::new("x", DataType::Int32, true)), + Arc::new(Int32Array::from(vec![1, 2])) as ArrayRef, + ), + ( + Arc::new(Field::new("z", DataType::Utf8, true)), + Arc::new(StringArray::from(vec!["a", "b"])) as ArrayRef, + ), + ])); + assert!(keys_equal(s1.as_ref(), 0, renamed.as_ref(), 0).unwrap()); + } +} diff --git a/crates/krishiv-plan-codec/src/decode.rs b/crates/krishiv-plan-codec/src/decode.rs index 6954484f7..44ad054ad 100644 --- a/crates/krishiv-plan-codec/src/decode.rs +++ b/crates/krishiv-plan-codec/src/decode.rs @@ -297,6 +297,7 @@ fn plan(m: &pb::PhysicalPlan, limits: &Limits) -> Result { zone: env.zone, query_start_micros: env.query_start_micros, user: Arc::from(env.user.as_str()), + map_key_dedup_last_win: env.map_key_dedup_last_win.unwrap_or(false), }; Ok( PhysicalPlan::new(root, schema_from(&m.schema)?, explain, env) diff --git a/crates/krishiv-plan-codec/src/encode.rs b/crates/krishiv-plan-codec/src/encode.rs index 3684f3315..230ac32a5 100644 --- a/crates/krishiv-plan-codec/src/encode.rs +++ b/crates/krishiv-plan-codec/src/encode.rs @@ -131,6 +131,7 @@ fn env(env: &ExprEnv) -> pb::ExprEnv { query_start_micros: env.query_start_micros, user: env.user.to_string(), legacy_statistical_aggregate: env.legacy_statistical_aggregate, + map_key_dedup_last_win: env.map_key_dedup_last_win.then_some(true), } } diff --git a/crates/krishiv-plan-codec/src/features.rs b/crates/krishiv-plan-codec/src/features.rs index ba93b5390..35519a85d 100644 --- a/crates/krishiv-plan-codec/src/features.rs +++ b/crates/krishiv-plan-codec/src/features.rs @@ -125,6 +125,7 @@ registry! { (lambda_functions, LambdaFunctions, POST_MIGRATION_READER_VERSION, Semantic, "Lambda expressions (`x -> body`) and variables: the bound bodies of higher-order function arguments (`transform`, `filter`, `exists`, `forall`)."), (legacy_statistical_aggregate, LegacyStatisticalAggregate, POST_MIGRATION_READER_VERSION, Semantic, "The `legacy_statistical_aggregate` expression environment flag (`spark.sql.legacy.statisticalAggregate`): the sample moment aggregates give NaN instead of NULL where Spark divides by zero."), (limit_offset, LimitOffset, 3, Semantic, "A `Limit` that skips leading rows (a nonzero offset)."), + (map_key_dedup_policy, MapKeyDedupPolicy, POST_MIGRATION_READER_VERSION, Semantic, "The session's map-key dedup policy (`LAST_WIN`); without it a worker keeps the first value on duplicate map keys."), (nested_types, NestedTypes, POST_MIGRATION_READER_VERSION, Semantic, "Array, map and struct types (`DataType.KIND_NESTED`, written as Spark's JSON form of the type)."), (struct_field, StructField, POST_MIGRATION_READER_VERSION, Semantic, "A struct field access (`GetStructField`: the analyzer-resolved field of a struct)."), (window, Window, 4, Semantic, "The `Window` node and its functions."), @@ -491,6 +492,9 @@ fn exprs_of<'a>(node: &'a PhysNode) -> Vec<&'a Arc> { #[must_use] pub fn plan_features(plan: &PhysicalPlan) -> BTreeSet { let mut out = BTreeSet::new(); + if plan.env().map_key_dedup_last_win { + out.insert(Feature::MapKeyDedupPolicy); + } let mut has_moment = false; let mut stack = vec![plan.root()]; while let Some(node) = stack.pop() { diff --git a/crates/krishiv-plan-codec/src/proto/krishiv.plan.v1.pb.rs b/crates/krishiv-plan-codec/src/proto/krishiv.plan.v1.pb.rs index c5581730e..1ad6521cd 100644 --- a/crates/krishiv-plan-codec/src/proto/krishiv.plan.v1.pb.rs +++ b/crates/krishiv-plan-codec/src/proto/krishiv.plan.v1.pb.rs @@ -72,6 +72,11 @@ pub struct ExprEnv { /// give NaN instead of NULL where Spark divides by zero. #[prost(bool, tag = "5")] pub legacy_statistical_aggregate: bool, + /// The session's map-key dedup policy: a worker without the feature keeps + /// the first value on duplicate map keys. + /// feature: map_key_dedup_policy + #[prost(bool, optional, tag = "6")] + pub map_key_dedup_last_win: ::core::option::Option, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct ExplainNode { diff --git a/crates/krishiv-plan-codec/tests/common/inventory.rs b/crates/krishiv-plan-codec/tests/common/inventory.rs index 5b94f2305..5829c139a 100644 --- a/crates/krishiv-plan-codec/tests/common/inventory.rs +++ b/crates/krishiv-plan-codec/tests/common/inventory.rs @@ -37,6 +37,7 @@ pub(crate) fn env() -> ExprEnv { zone: Some(-28_800), query_start_micros: 1_760_000_000_123_456, user: Arc::from("analyst"), + map_key_dedup_last_win: false, } } @@ -1030,9 +1031,20 @@ pub(crate) fn cases() -> Vec<(String, PhysicalPlan)> { out.push(("nested_types".to_owned(), plan_of(nested_types()))); out.push(("lambda_functions".to_owned(), plan_of(lambda_functions()))); out.push(("struct_field".to_owned(), plan_of(struct_field()))); + out.push(("map_key_dedup_policy".to_owned(), map_key_dedup_policy())); out } +/// A plan whose environment sets the map-key dedup policy to `LAST_WIN`. +fn map_key_dedup_policy() -> PhysicalPlan { + let env = ExprEnv { + map_key_dedup_last_win: true, + ..env() + }; + let explain = ExplainNode::new("Root", "details", vec![]); + PhysicalPlan::new(PhysNode::OneRow, schema(), explain, env) +} + /// A struct field access (`GetStructField`): the `b` of a struct column. pub(crate) fn struct_field() -> PhysNode { let t = |s: &str| parse_data_type(s).unwrap(); diff --git a/crates/krishiv-plan-codec/tests/golden/map_key_dedup_policy/map_key_dedup_policy.bin b/crates/krishiv-plan-codec/tests/golden/map_key_dedup_policy/map_key_dedup_policy.bin new file mode 100644 index 000000000..f4fff1b59 Binary files /dev/null and b/crates/krishiv-plan-codec/tests/golden/map_key_dedup_policy/map_key_dedup_policy.bin differ diff --git a/crates/krishiv-plan-codec/tests/roundtrip.rs b/crates/krishiv-plan-codec/tests/roundtrip.rs index e4c1cf20c..110323e73 100644 --- a/crates/krishiv-plan-codec/tests/roundtrip.rs +++ b/crates/krishiv-plan-codec/tests/roundtrip.rs @@ -293,7 +293,11 @@ fn readers_that_predate_features_still_refuse_what_they_cannot_read() { "window_ranking" | "window_aggregates" => 4, n if n.starts_with("expand") => 5, // A feature added after the freeze: above every frozen version. - "window_group_limit" | "nested_types" | "struct_field" | "lambda_functions" => 6, + "window_group_limit" + | "nested_types" + | "struct_field" + | "lambda_functions" + | "map_key_dedup_policy" => 6, n if n.starts_with("hash_join_right") => POST_MIGRATION_READER_VERSION, "hash_join_existence" | "hash_join_single_match" diff --git a/crates/krishiv-plan/src/analyzer/coerce.rs b/crates/krishiv-plan/src/analyzer/coerce.rs index 4713d7694..a9cb9bff1 100644 --- a/crates/krishiv-plan/src/analyzer/coerce.rs +++ b/crates/krishiv-plan/src/analyzer/coerce.rs @@ -101,6 +101,12 @@ pub(super) enum Mismatch { /// `DATA_DIFF_TYPES`: the argument types; whether Spark lists them as /// `["A", "B"]` (else `("A" or "B")`). DataDiff(Vec>, bool), + /// `CREATE_MAP_KEY_DIFF_TYPES`: the key types of `map`. + CreateMapKeyDiff(Vec>), + /// `CREATE_MAP_VALUE_DIFF_TYPES`: the value types of `map`. + CreateMapValueDiff(Vec>), + /// `MAP_CONCAT_DIFF_TYPES`: the argument types of `map_concat`. + MapConcatDiffTypes(Vec>), /// `INVALID_ORDERING_TYPE`: a type that does not order (a map). InvalidOrdering(DataType), /// A coercion Krishiv does not implement. @@ -253,6 +259,16 @@ fn complex(x: &DataType, y: &DataType, rules: Rules, how: Nested) -> Option`. +fn null_array() -> DataType { + ArrayType::new(DataType::Null, true).into() +} + +/// An untyped `NULL` as a map: `map`. +fn null_map() -> DataType { + MapType::new(DataType::Null, DataType::Null, true).into() +} + /// An element of a nested type as an argument: `void` is an untyped NULL. fn elem(t: &DataType) -> Arg<'_> { Arg { @@ -861,6 +877,9 @@ pub(super) fn inputs( ) -> Result>, Mismatch> { match inputs { Inputs::Common => common_casts(args, args, Rules::of(call)), + Inputs::Map => map_casts(args, Rules::of(call)), + Inputs::MapConcat => map_concat_casts(args, Rules::of(call)), + Inputs::MapContainsKey => map_contains_key_casts(args, call), Inputs::CommonNoStrings => { let typed = args.iter().filter(|a| a.ty.is_some()); let strings = typed @@ -979,6 +998,95 @@ fn common_casts( Ok(args.iter().map(|a| cast_to(a.ty, t.as_ref())).collect()) } +/// `map(k1, v1, ...)`: the keys (even positions) and the values (odd) each +/// meet at their common type (`CREATE_MAP_KEY_DIFF_TYPES` and +/// `CREATE_MAP_VALUE_DIFF_TYPES` when either side has none). +fn map_casts(args: &[Arg<'_>], rules: Rules) -> Result>, Mismatch> { + let keys: Vec> = args.iter().step_by(2).copied().collect(); + let values: Vec> = args.iter().skip(1).step_by(2).copied().collect(); + let key_type = common_all(&keys, rules) + .ok_or_else(|| Mismatch::CreateMapKeyDiff(keys.iter().map(|a| a.ty.cloned()).collect()))?; + let value_type = common_all(&values, rules).ok_or_else(|| { + Mismatch::CreateMapValueDiff(values.iter().map(|a| a.ty.cloned()).collect()) + })?; + Ok(args + .iter() + .enumerate() + .map(|(i, a)| { + let to = if i % 2 == 0 { &key_type } else { &value_type }; + cast_to(a.ty, to.as_ref()) + }) + .collect()) +} + +/// `map_concat(m1, ...)`: every argument must be a map +/// (`MAP_CONCAT_DIFF_TYPES` otherwise, an untyped `NULL` included). With +/// ANSI the maps must share the type ignoring nullability; without it they +/// meet at their common type (`DATA_DIFF_TYPES` either way). +fn map_concat_casts(args: &[Arg<'_>], rules: Rules) -> Result>, Mismatch> { + if args.iter().any(|a| !matches!(a.ty, Some(DataType::Map(_)))) { + return Err(Mismatch::MapConcatDiffTypes( + args.iter().map(|a| a.ty.cloned()).collect(), + )); + } + if rules.ansi { + let same = match args.first() { + None => true, + Some(first) => args.iter().all(|a| match (&first.ty, &a.ty) { + (Some(x), Some(y)) => x.equals_ignore_nullability(y), + _ => false, + }), + }; + if !same { + return Err(Mismatch::DataDiff( + args.iter().map(|a| a.ty.cloned()).collect(), + false, + )); + } + return Ok(vec![None; args.len()]); + } + common_casts(args, args, rules) +} + +/// `map_contains_key(map, key)`: the key meets the map's key type without +/// string promotion, and both are cast to the wider key type; no casts when +/// there is none (the result rule reports it). +fn map_contains_key_casts( + args: &[Arg<'_>], + call: &CallTypes<'_>, +) -> Result>, Mismatch> { + let [map, key] = args else { + return Ok(vec![None; args.len()]); + }; + let wider = match (&map.ty, &key.ty) { + (Some(DataType::Map(m)), Some(k)) => { + let wider = wider_type_without_string_promotion( + &elem(m.key_type()), + &elem(k), + call.case_sensitive(), + ); + match wider { + Some(Some(w)) => { + if m.key_type().equals_ignore_nullability(&w) && !orderable(m.key_type()) { + return Err(Mismatch::InvalidOrdering(m.key_type().clone())); + } + Some((m.value_type().clone(), m.value_contains_null(), w)) + } + _ => None, + } + } + _ => None, + }; + let Some((value_type, value_contains_null, wider)) = wider else { + return Ok(vec![None; args.len()]); + }; + let map_type = MapType::new(wider.clone(), value_type, value_contains_null); + Ok(vec![ + cast_to(map.ty, Some(&map_type.into())), + cast_to(key.ty, Some(&wider)), + ]) +} + /// The literal `0` of `zeroifnull` and `nullifzero`. fn hidden_zero() -> Arg<'static> { Arg { @@ -1009,7 +1117,9 @@ fn declared(types: &[InputType], args: &[Arg<'_>]) -> Result, want: &InputType) -> Option> { use DataType as T; match (from, want) { - (_, InputType::Any) => Some(from.cloned()), + (_, InputType::Any) + | (Some(DataType::Map(_)), InputType::Map) + | (Some(DataType::Array(_)), InputType::Array) => Some(from.cloned()), (Some(t), InputType::Numeric { .. }) if is_numeric(t) => Some(Some(t.clone())), (None | Some(T::String), InputType::Numeric { .. }) => Some(Some(T::Double)), // A type of the collection stays; another takes the first member @@ -1025,6 +1135,13 @@ fn implicit(from: Option<&DataType>, want: &InputType) -> Option Some(Some(t.clone())), (Some(f), InputType::Strict(t)) => (f == t).then(|| Some(t.clone())), + (None, InputType::Map) => Some(Some(null_map())), + (None, InputType::Array) => Some(Some(null_array())), + // A nested type casts to another only element by element, where a + // target that may not hold NULL needs a source that has none. + (Some(f), InputType::Exact(t)) if f.is_nested() && t.is_nested() => { + nested_cast(f, t, CastMode::Ansi).then(|| Some(t.clone())) + } (Some(f), InputType::Exact(t)) => { let from_string = is_numeric(t) || matches!( @@ -1287,6 +1404,13 @@ pub(super) fn quoted_type(t: Option<&DataType>) -> String { format!("\"{}\"", t.map_or_else(|| "VOID".to_owned(), DataType::sql)) } +/// Types as Spark's `CREATE_MAP_*_DIFF_TYPES` and `MAP_CONCAT_DIFF_TYPES` +/// list them: `["INT", "STRING"]`. +pub(super) fn list_types(types: &[Option]) -> String { + let types: Vec = types.iter().map(|t| quoted_type(t.as_ref())).collect(); + format!("[{}]", types.join(", ")) +} + #[cfg(test)] mod tests { use krishiv_types::DataType as T; diff --git a/crates/krishiv-plan/src/analyzer/exprs.rs b/crates/krishiv-plan/src/analyzer/exprs.rs index d91c8a87a..8c776bec0 100644 --- a/crates/krishiv-plan/src/analyzer/exprs.rs +++ b/crates/krishiv-plan/src/analyzer/exprs.rs @@ -10,10 +10,12 @@ use krishiv_common::error::{ CannotResolveDataframeColumn, CannotResolveStarExpand, DatatypeMismatchBinaryOpDiffTypes, DatatypeMismatchBinaryOpWrongType, DatatypeMismatchCastWithConfSuggestion, DatatypeMismatchCastWithFuncSuggestion, DatatypeMismatchCastWithoutSuggestion, + DatatypeMismatchCreateMapKeyDiffTypes, DatatypeMismatchCreateMapValueDiffTypes, DatatypeMismatchDataDiffTypes, DatatypeMismatchInSubqueryDataTypeMismatch, DatatypeMismatchInSubqueryLengthMismatch, DatatypeMismatchInputSizeNotOne, - DatatypeMismatchInvalidOrderingType, DatatypeMismatchNonFoldableInput, - DatatypeMismatchUnexpectedInputType, DuplicateRoutineParameterAssignmentBothPositionalAndNamed, + DatatypeMismatchInvalidOrderingType, DatatypeMismatchMapConcatDiffTypes, + DatatypeMismatchNonFoldableInput, DatatypeMismatchUnexpectedInputType, + DuplicateRoutineParameterAssignmentBothPositionalAndNamed, DuplicateRoutineParameterAssignmentDoubleNamedArgumentReference, ExceptOverlappingColumns, FailedToParseTooComplex, InternalError, InvalidAggregateFilterNotBoolean, InvalidExtractBaseFieldType, @@ -31,7 +33,7 @@ use super::analytics::GroupingFn; use super::bind::{addr, qualified_parts, same, unsupported}; use super::builtins::{NamedDefault, NamedParam, named_signature}; use super::catalog::quoted; -use super::coerce::{self, Arg, BadCast, Mismatch, ordinal, quoted_type}; +use super::coerce::{self, Arg, BadCast, Mismatch, list_types, ordinal, quoted_type}; use super::fold; use super::resolve::{Attr, Env, RESOLVE_STEP, Rel, Resolver}; use super::suggest::closest; @@ -1758,7 +1760,12 @@ impl Resolver<'_> { /// session's settings, with `ansi` for the arithmetic: shared with /// every other fold of the pass. pub(super) fn fold(&self, e: &Arc, ansi: bool) -> Option { - let conf = fold::Conf::new(ansi, self.ctx.conf.decimal_precision_loss, self.ctx.profile); + let conf = fold::Conf::new( + ansi, + self.ctx.conf.decimal_precision_loss, + self.ctx.conf.map_key_dedup_last_win, + self.ctx.profile, + ); fold::constant(e, conf, &mut self.folds.borrow_mut()) } @@ -2811,6 +2818,24 @@ impl Resolver<'_> { } .into() } + Mismatch::CreateMapKeyDiff(types) => DatatypeMismatchCreateMapKeyDiffTypes { + sql_expr, + function_name: "`map`".to_owned(), + data_type: list_types(&types), + } + .into(), + Mismatch::CreateMapValueDiff(types) => DatatypeMismatchCreateMapValueDiffTypes { + sql_expr, + function_name: "`map`".to_owned(), + data_type: list_types(&types), + } + .into(), + Mismatch::MapConcatDiffTypes(types) => DatatypeMismatchMapConcatDiffTypes { + sql_expr, + function_name: "`map_concat`".to_owned(), + data_type: list_types(&types), + } + .into(), Mismatch::InvalidOrdering(t) => DatatypeMismatchInvalidOrderingType { sql_expr, function_name: quoted(&[function.to_owned()]), diff --git a/crates/krishiv-plan/src/analyzer/fold.rs b/crates/krishiv-plan/src/analyzer/fold.rs index e456069b9..171480fe6 100644 --- a/crates/krishiv-plan/src/analyzer/fold.rs +++ b/crates/krishiv-plan/src/analyzer/fold.rs @@ -61,6 +61,8 @@ pub(super) struct Conf { pub ansi: bool, /// `spark.sql.decimalOperations.allowPrecisionLoss`. pub decimal_loss: bool, + /// `spark.sql.mapKeyDedupPolicy = LAST_WIN`. + pub map_key_dedup_last_win: bool, /// The kernels' context: the session's Spark line, whose error classes /// and messages the kernels raise. pub kernel: KernelCtx, @@ -68,7 +70,12 @@ pub(super) struct Conf { impl Conf { /// The settings of a session on `profile`. - pub(super) fn new(ansi: bool, decimal_loss: bool, profile: SparkProfile) -> Self { + pub(super) fn new( + ansi: bool, + decimal_loss: bool, + map_key_dedup_last_win: bool, + profile: SparkProfile, + ) -> Self { // The kernels model 4.0 as their oldest line; 3.5 behaves as it. let version = match profile { SparkProfile::V3_5 | SparkProfile::V4_0 => SparkVersion::V4_0, @@ -78,6 +85,7 @@ impl Conf { Self { ansi, decimal_loss, + map_key_dedup_last_win, kernel: KernelCtx::new().with_spark_version(version), } } @@ -89,7 +97,7 @@ type Folded = Option>; /// What a folded node's value depends on besides the node: its address /// and the settings it was folded under. -type Key = (usize, bool, bool, SparkVersion); +type Key = (usize, bool, bool, bool, SparkVersion); /// The values of the expressions folded so far in one resolver pass, by /// node address. Folding a call folds its arguments, and `Resolver::expr` @@ -222,6 +230,7 @@ fn fold_on_stack(e: &Arc, conf: Conf, memo: &mut Memo) -> Folded { Arc::as_ptr(e) as usize, conf.ansi, conf.decimal_loss, + conf.map_key_dedup_last_win, conf.kernel.spark_version(), ); if let Some((_, hit)) = memo.map.get(&key) { @@ -480,10 +489,17 @@ fn registry( { return None; } + use krishiv_kernels::map::DedupPolicy; + let policy = if conf.map_key_dedup_last_win { + DedupPolicy::LastWin + } else { + DedupPolicy::Exception + }; let opts = BindOptions::new() .with_kernel(conf.kernel) .with_ansi(conf.ansi) - .with_decimal_precision_loss(conf.decimal_loss); + .with_decimal_precision_loss(conf.decimal_loss) + .with_map_key_dedup_policy(policy); let bind: Vec = args.iter().cloned().map(BindArg::Literal).collect(); let run = bind_scalar(name, &bind, &opts).and_then(|func| { let call: Vec = args.into_iter().map(Arg::Scalar).collect(); @@ -551,7 +567,7 @@ mod tests { fn constant(e: &Expr, ansi: bool) -> Option { super::constant( &Arc::new(e.clone()), - Conf::new(ansi, true, SparkProfile::V4_2), + Conf::new(ansi, true, false, SparkProfile::V4_2), &mut Memo::default(), ) } @@ -851,7 +867,7 @@ mod tests { }, )))); } - let conf = Conf::new(false, true, SparkProfile::V4_2); + let conf = Conf::new(false, true, false, SparkProfile::V4_2); let mut memo = Memo::default(); // 2 * 2^200 wraps to 0 in legacy mode: the value is the kernels'. let first = super::constant(&e, conf, &mut memo); @@ -860,7 +876,7 @@ mod tests { assert_eq!(super::constant(&e, conf, &mut memo), first); assert_eq!(memo.map.len(), depth + 1); // Another setting folds under its own entries. - let ansi = Conf::new(true, true, SparkProfile::V4_2); + let ansi = Conf::new(true, true, false, SparkProfile::V4_2); let _ = super::constant(&e, ansi, &mut memo); assert_eq!(memo.map.len(), 2 * (depth + 1)); } @@ -876,7 +892,7 @@ mod tests { )); let class = |profile| match super::constant( &rem, - Conf::new(true, true, profile), + Conf::new(true, true, false, profile), &mut Memo::default(), ) { Some(Constant::Error(e)) => e.error_class(), @@ -1244,7 +1260,7 @@ mod tests { std::thread::Builder::new() .stack_size(2 << 20) .spawn(move || { - let conf = Conf::new(false, true, SparkProfile::V4_2); + let conf = Conf::new(false, true, false, SparkProfile::V4_2); let mut memo = Memo::default(); assert_eq!( super::constant(&e, conf, &mut memo), diff --git a/crates/krishiv-plan/src/analyzer/mod.rs b/crates/krishiv-plan/src/analyzer/mod.rs index 8233bd747..9f82068b4 100644 --- a/crates/krishiv-plan/src/analyzer/mod.rs +++ b/crates/krishiv-plan/src/analyzer/mod.rs @@ -129,6 +129,9 @@ pub struct ResolutionConf { /// `spark.sql.decimalOperations.allowPrecisionLoss`: decimal /// arithmetic result types. pub decimal_precision_loss: bool, + /// `spark.sql.mapKeyDedupPolicy = LAST_WIN`: duplicate map keys keep + /// the value inserted last (folded map calls depend on it). + pub map_key_dedup_last_win: bool, /// `spark.sql.runSQLOnFiles`: `` format.`path` `` reads files. pub run_sql_on_files: bool, /// `spark.sql.timestampType = TIMESTAMP_NTZ`: plain `TIMESTAMP '...'` @@ -153,6 +156,7 @@ impl Default for ResolutionConf { order_by_ordinal: true, lateral_column_alias: true, decimal_precision_loss: true, + map_key_dedup_last_win: false, run_sql_on_files: true, timestamp_ntz: false, session_zone: Some(0), @@ -162,7 +166,7 @@ impl Default for ResolutionConf { impl ResolutionConf { /// The session configs [`Self::from_conf`] reads: the only ones. - pub const KEYS: [&'static str; 10] = [ + pub const KEYS: [&'static str; 11] = [ "spark.sql.caseSensitive", "spark.sql.ansi.enabled", "spark.sql.groupByAliases", @@ -171,6 +175,7 @@ impl ResolutionConf { "spark.sql.lateralColumnAlias.enableImplicitResolution", "spark.sql.decimalOperations.allowPrecisionLoss", "spark.sql.runSQLOnFiles", + "spark.sql.mapKeyDedupPolicy", "spark.sql.timestampType", "spark.sql.session.timeZone", ]; @@ -202,9 +207,11 @@ impl ResolutionConf { lateral_column_alias: v[5], decimal_precision_loss: v[6], run_sql_on_files: v[7], - timestamp_ntz: conf(Self::KEYS[8]) + map_key_dedup_last_win: conf(Self::KEYS[8]) + .is_some_and(|s| s.trim().eq_ignore_ascii_case("LAST_WIN")), + timestamp_ntz: conf(Self::KEYS[9]) .is_some_and(|s| s.trim().eq_ignore_ascii_case("TIMESTAMP_NTZ")), - session_zone: match conf(Self::KEYS[9]) { + session_zone: match conf(Self::KEYS[10]) { None => Some(0), Some(s) => krishiv_kernels::cast::FixedOffset::parse(s).map(|o| o.0), }, @@ -289,6 +296,7 @@ impl ContextFingerprint { c.order_by_ordinal, c.lateral_column_alias, c.decimal_precision_loss, + c.map_key_dedup_last_win, c.run_sql_on_files, c.timestamp_ntz, self.files, diff --git a/crates/krishiv-session/tests/datetime_calendar.rs b/crates/krishiv-session/tests/datetime_calendar.rs index b6d406768..17722aed4 100644 --- a/crates/krishiv-session/tests/datetime_calendar.rs +++ b/crates/krishiv-session/tests/datetime_calendar.rs @@ -291,7 +291,7 @@ fn matrix_cells_match_spark() { // instead of passing silently. assert_eq!(tally.not_run, expected_not_run(), "{report}"); assert_eq!(tally.normalized_cast_invalid_input, 96, "{report}"); - assert_eq!(tally.normalized_months_between, 48, "{report}"); + assert_eq!(tally.normalized_months_between, 52, "{report}"); } /// The exact cells the engine does not run: region time zones (no tz @@ -302,7 +302,7 @@ fn expected_not_run() -> BTreeMap { BTreeMap::from([ ( "analysis errors of the rewritten convert_timezone".to_owned(), - 28, + 32, ), ("cast of invalid UTF-8 bytes to a string".to_owned(), 23), ("no recorded rows".to_owned(), 62), @@ -311,7 +311,6 @@ fn expected_not_run() -> BTreeMap { ("unsupported: INTERVAL literals".to_owned(), 144), ("unsupported: TIME literals".to_owned(), 6), ("unsupported: function DATE".to_owned(), 4), - ("unsupported: function map".to_owned(), 74), ( "unsupported: the function convert_timezone (it has no binding for these arguments: a region time zone)" .to_owned(), diff --git a/crates/krishiv-session/tests/map_type_errors.rs b/crates/krishiv-session/tests/map_type_errors.rs new file mode 100644 index 000000000..524a234a4 --- /dev/null +++ b/crates/krishiv-session/tests/map_type_errors.rs @@ -0,0 +1,39 @@ +// SPDX-License-Identifier: Apache-2.0 +//! Type errors the map constructors and `map_concat` raise at analysis time. +#![cfg(test)] + +use futures::executor::block_on; +use krishiv_common::error::ErrorClass; +use krishiv_session::Session; + +fn class_of(sql: &str) -> ErrorClass { + let s = Session::new().unwrap(); + match block_on(s.sql(sql)) { + Ok(_) => panic!("{sql} resolved"), + Err(e) => e.error_class(), + } +} + +#[test] +fn map_keys_without_a_common_type_are_rejected() { + assert_eq!( + class_of("SELECT map(true, 'a', DATE '2020-01-01', 'b')"), + ErrorClass::DatatypeMismatchCreateMapKeyDiffTypes + ); +} + +#[test] +fn map_values_without_a_common_type_are_rejected() { + assert_eq!( + class_of("SELECT map('a', 1, 'b', map(1, 2))"), + ErrorClass::DatatypeMismatchCreateMapValueDiffTypes + ); +} + +#[test] +fn map_concat_of_a_non_map_argument_is_rejected() { + assert_eq!( + class_of("SELECT map_concat(map(1, 'a'), 1)"), + ErrorClass::DatatypeMismatchMapConcatDiffTypes + ); +} diff --git a/proto/krishiv/plan/v1/plan.proto b/proto/krishiv/plan/v1/plan.proto index 72d61512d..69da708cf 100644 --- a/proto/krishiv/plan/v1/plan.proto +++ b/proto/krishiv/plan/v1/plan.proto @@ -78,6 +78,10 @@ message ExprEnv { // `spark.sql.legacy.statisticalAggregate`: the sample moment aggregates // give NaN instead of NULL where Spark divides by zero. bool legacy_statistical_aggregate = 5; + // The session's map-key dedup policy: a worker without the feature keeps + // the first value on duplicate map keys. + // feature: map_key_dedup_policy + optional bool map_key_dedup_last_win = 6; } message ExplainNode { diff --git a/python/krishiv/sql/_generated_functions.py b/python/krishiv/sql/_generated_functions.py index 12d2e94a8..0152ea16d 100644 --- a/python/krishiv/sql/_generated_functions.py +++ b/python/krishiv/sql/_generated_functions.py @@ -64,6 +64,7 @@ "covar_pop", "covar_samp", "crc32", + "create_map", "csc", "cume_dist", "curdate", @@ -140,6 +141,13 @@ "ltrim", "make_date", "make_valid_utf8", + "map_concat", + "map_contains_key", + "map_entries", + "map_from_arrays", + "map_from_entries", + "map_keys", + "map_values", "mask", "max", "md5", @@ -220,6 +228,7 @@ "stddev", "stddev_pop", "stddev_samp", + "str_to_map", "struct", "substr", "substring", @@ -467,6 +476,11 @@ def crc32(col: ColumnOrName) -> Column: return _call("crc32", _named(col, "col")) +def create_map(*cols: ColumnOrName) -> Column: + """Calls the registry function ``map``.""" + return _call("map", *_cols(cols)) + + def csc(col: ColumnOrName) -> Column: """Calls the registry function ``csc``.""" return _call("csc", _named(col, "col")) @@ -849,6 +863,41 @@ def make_valid_utf8(str: ColumnOrName) -> Column: return _call("make_valid_utf8", _named(str, "str")) +def map_concat(*cols: ColumnOrName) -> Column: + """Calls the registry function ``map_concat``.""" + return _call("map_concat", *_cols(cols)) + + +def map_contains_key(col: ColumnOrName, value: Any) -> Column: + """Calls the registry function ``map_contains_key``.""" + return _call("map_contains_key", _named(col, "col"), _lit(value, "value")) + + +def map_entries(col: ColumnOrName) -> Column: + """Calls the registry function ``map_entries``.""" + return _call("map_entries", _named(col, "col")) + + +def map_from_arrays(col1: ColumnOrName, col2: ColumnOrName) -> Column: + """Calls the registry function ``map_from_arrays``.""" + return _call("map_from_arrays", _named(col1, "col1"), _named(col2, "col2")) + + +def map_from_entries(col: ColumnOrName) -> Column: + """Calls the registry function ``map_from_entries``.""" + return _call("map_from_entries", _named(col, "col")) + + +def map_keys(col: ColumnOrName) -> Column: + """Calls the registry function ``map_keys``.""" + return _call("map_keys", _named(col, "col")) + + +def map_values(col: ColumnOrName) -> Column: + """Calls the registry function ``map_values``.""" + return _call("map_values", _named(col, "col")) + + def mask( col: ColumnOrName, upperChar: ColumnOrName | None = None, @@ -1268,6 +1317,20 @@ def stddev_samp(col: ColumnOrName) -> Column: return _call("stddev_samp", _named(col, "col")) +def str_to_map( + text: ColumnOrName, pairDelim: ColumnOrName | None = None, keyValueDelim: ColumnOrName | None = None +) -> Column: + """Calls the registry function ``str_to_map``.""" + if pairDelim is None and keyValueDelim is not None: + return _call("str_to_map", _named(text, "text"), _lit(",", "pairDelim"), _named(keyValueDelim, "keyValueDelim")) + return _call( + "str_to_map", + _named(text, "text"), + *_opt(_named, pairDelim, "pairDelim"), + *_opt(_named, keyValueDelim, "keyValueDelim"), + ) + + def struct(*cols: ColumnOrName) -> Column: """Calls the registry function ``struct``.""" return _call("struct", *_cols(cols)) diff --git a/python/krishiv/sql/_generated_functions.pyi b/python/krishiv/sql/_generated_functions.pyi index ac43727be..3ebd05c35 100644 --- a/python/krishiv/sql/_generated_functions.pyi +++ b/python/krishiv/sql/_generated_functions.pyi @@ -45,6 +45,7 @@ __all__ = [ "covar_pop", "covar_samp", "crc32", + "create_map", "csc", "cume_dist", "curdate", @@ -121,6 +122,13 @@ __all__ = [ "ltrim", "make_date", "make_valid_utf8", + "map_concat", + "map_contains_key", + "map_entries", + "map_from_arrays", + "map_from_entries", + "map_keys", + "map_values", "mask", "max", "md5", @@ -201,6 +209,7 @@ __all__ = [ "stddev", "stddev_pop", "stddev_samp", + "str_to_map", "struct", "substr", "substring", @@ -290,6 +299,7 @@ def cot(col: ColumnOrName) -> Column: ... def covar_pop(col1: ColumnOrName, col2: ColumnOrName) -> Column: ... def covar_samp(col1: ColumnOrName, col2: ColumnOrName) -> Column: ... def crc32(col: ColumnOrName) -> Column: ... +def create_map(*cols: ColumnOrName) -> Column: ... def csc(col: ColumnOrName) -> Column: ... def cume_dist() -> Column: ... def curdate() -> Column: ... @@ -366,6 +376,13 @@ def lpad(col: ColumnOrName, len: Column | int, pad: Column | str) -> Column: ... def ltrim(col: ColumnOrName, trim: ColumnOrName | None = None) -> Column: ... def make_date(year: ColumnOrName, month: ColumnOrName, day: ColumnOrName) -> Column: ... def make_valid_utf8(str: ColumnOrName) -> Column: ... +def map_concat(*cols: ColumnOrName) -> Column: ... +def map_contains_key(col: ColumnOrName, value: Any) -> Column: ... +def map_entries(col: ColumnOrName) -> Column: ... +def map_from_arrays(col1: ColumnOrName, col2: ColumnOrName) -> Column: ... +def map_from_entries(col: ColumnOrName) -> Column: ... +def map_keys(col: ColumnOrName) -> Column: ... +def map_values(col: ColumnOrName) -> Column: ... def mask( col: ColumnOrName, upperChar: ColumnOrName | None = None, @@ -454,6 +471,9 @@ def std(col: ColumnOrName) -> Column: ... def stddev(col: ColumnOrName) -> Column: ... def stddev_pop(col: ColumnOrName) -> Column: ... def stddev_samp(col: ColumnOrName) -> Column: ... +def str_to_map( + text: ColumnOrName, pairDelim: ColumnOrName | None = None, keyValueDelim: ColumnOrName | None = None +) -> Column: ... def struct(*cols: ColumnOrName) -> Column: ... def substr(str: ColumnOrName, pos: ColumnOrName, len: ColumnOrName | None = None) -> Column: ... def substring(str: ColumnOrName, pos: ColumnOrName | int, len: ColumnOrName | int) -> Column: ... diff --git a/python/tests/_pyspark_signatures.py b/python/tests/_pyspark_signatures.py index e02742a6d..2e656ebf9 100644 --- a/python/tests/_pyspark_signatures.py +++ b/python/tests/_pyspark_signatures.py @@ -56,6 +56,7 @@ "covar_pop": "col1, col2", "covar_samp": "col1, col2", "crc32": "col", + "create_map": "*cols", "csc": "col", "cume_dist": "", "curdate": "", @@ -136,6 +137,13 @@ "ltrim": "col, trim=None", "make_date": "year, month, day", "make_valid_utf8": "str", + "map_concat": "*cols", + "map_contains_key": "col, value", + "map_entries": "col", + "map_from_arrays": "col1, col2", + "map_from_entries": "col", + "map_keys": "col", + "map_values": "col", "mask": "col, upperChar=None, lowerChar=None, digitChar=None, otherChar=None", "max": "col", "md5": "col", @@ -216,6 +224,7 @@ "stddev": "col", "stddev_pop": "col", "stddev_samp": "col", + "str_to_map": "text, pairDelim=None, keyValueDelim=None", "struct": "*cols", "substr": "str, pos, len=None", "substring": "str, pos, len", diff --git a/python/tests/test_generated_functions.py b/python/tests/test_generated_functions.py index 68554d1c0..6474bae50 100644 --- a/python/tests/test_generated_functions.py +++ b/python/tests/test_generated_functions.py @@ -29,6 +29,7 @@ REGISTRY_NAME = { "bitwise_not": "~", "bitwiseNOT": "~", + "create_map": "map", "mean": "avg", "pow": "power", "shiftLeft": "shiftleft", diff --git a/tests/fixtures/analysis/registry-matrix/%26.json b/tests/fixtures/analysis/registry-matrix/%26.json index 6ea8afb7e..e5299b20f 100644 --- a/tests/fixtures/analysis/registry-matrix/%26.json +++ b/tests/fixtures/analysis/registry-matrix/%26.json @@ -8,14 +8,6 @@ "id": "c1a16bec609/ansi_off", "reason": "SELECT 3 & (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "6c9405476fc/ansi_on", - "reason": "SELECT (map('a', 1)) & 5 | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "6c9405476fc/ansi_off", - "reason": "SELECT (map('a', 1)) & 5 | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "ᘛa97d9ba4/ansi_on", "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) & 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" @@ -32,14 +24,6 @@ "id": "ff00391103b/ansi_off", "reason": "SELECT (INTERVAL '1 02:03:04' DAY TO SECOND) & 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "⍥d84a5e85/ansi_on", - "reason": "SELECT 3 & (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "⍥d84a5e85/ansi_off", - "reason": "SELECT 3 & (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "&#c5402653e378/ansi_on", "reason": "SELECT 3 & (INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/%3C%3C.json b/tests/fixtures/analysis/registry-matrix/%3C%3C.json index 0fcc38470..75b6e5cd3 100644 --- a/tests/fixtures/analysis/registry-matrix/%3C%3C.json +++ b/tests/fixtures/analysis/registry-matrix/%3C%3C.json @@ -31,22 +31,6 @@ { "id": "<<#7e74e30d017a/ansi_off", "reason": "SELECT 2 << (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "<<#b68d0e5fe063/ansi_on", - "reason": "SELECT 2 << (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "<<#b68d0e5fe063/ansi_off", - "reason": "SELECT 2 << (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "<<#e95105f352b6/ansi_on", - "reason": "SELECT (map('a', 1)) << 1 | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "<<#e95105f352b6/ansi_off", - "reason": "SELECT (map('a', 1)) << 1 | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json b/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json index 41656bcf2..0d518ed93 100644 --- a/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json +++ b/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json @@ -16,14 +16,6 @@ "id": ">>>#6511ded1ecfe/ansi_off", "reason": "SELECT (INTERVAL '1 02:03:04' DAY TO SECOND) >>> 1 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": ">>>#74c691cd4e80/ansi_on", - "reason": "SELECT 4 >>> (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": ">>>#74c691cd4e80/ansi_off", - "reason": "SELECT 4 >>> (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": ">>>#a21b4f4deeef/ansi_on", "reason": "SELECT 4 >>> (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/%3E%3E.json b/tests/fixtures/analysis/registry-matrix/%3E%3E.json index 769c1f0d3..831c529c1 100644 --- a/tests/fixtures/analysis/registry-matrix/%3E%3E.json +++ b/tests/fixtures/analysis/registry-matrix/%3E%3E.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": ">>#03390ba511f0/ansi_on", - "reason": "SELECT 4 >> (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": ">>#03390ba511f0/ansi_off", - "reason": "SELECT 4 >> (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": ">>#0e4c7df33a27/ansi_on", "reason": "SELECT 4 >> (INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/%5E.json b/tests/fixtures/analysis/registry-matrix/%5E.json index b9425dd44..61f6674a5 100644 --- a/tests/fixtures/analysis/registry-matrix/%5E.json +++ b/tests/fixtures/analysis/registry-matrix/%5E.json @@ -24,14 +24,6 @@ "id": "^#83d0d49f9f79/ansi_off", "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) ^ 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "^#9c09c7c7c027/ansi_on", - "reason": "SELECT (map('a', 1)) ^ 5 | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "^#9c09c7c7c027/ansi_off", - "reason": "SELECT (map('a', 1)) ^ 5 | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "^#c88ccef66169/ansi_on", "reason": "SELECT 3 ^ (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" @@ -39,14 +31,6 @@ { "id": "^#c88ccef66169/ansi_off", "reason": "SELECT 3 ^ (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "^#dde005f750a0/ansi_on", - "reason": "SELECT 3 ^ (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "^#dde005f750a0/ansi_off", - "reason": "SELECT 3 ^ (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/%7C.json b/tests/fixtures/analysis/registry-matrix/%7C.json index 6d16f46be..d37566f89 100644 --- a/tests/fixtures/analysis/registry-matrix/%7C.json +++ b/tests/fixtures/analysis/registry-matrix/%7C.json @@ -31,22 +31,6 @@ { "id": "|#c2c41d6ca153/ansi_off", "reason": "SELECT (INTERVAL '1 02:03:04' DAY TO SECOND) | 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "|#d661d1cb45a4/ansi_on", - "reason": "SELECT 3 | (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "|#d661d1cb45a4/ansi_off", - "reason": "SELECT 3 | (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "|#f661d6f4219a/ansi_on", - "reason": "SELECT (map('a', 1)) | 5 | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "|#f661d6f4219a/ansi_off", - "reason": "SELECT (map('a', 1)) | 5 | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/%7E.json b/tests/fixtures/analysis/registry-matrix/%7E.json index e45f03a64..35a9de597 100644 --- a/tests/fixtures/analysis/registry-matrix/%7E.json +++ b/tests/fixtures/analysis/registry-matrix/%7E.json @@ -8,14 +8,6 @@ "id": "~#0580940297a9/ansi_off", "reason": "SELECT ~ (INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "~#3a505071af9d/ansi_on", - "reason": "SELECT ~ (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "~#3a505071af9d/ansi_off", - "reason": "SELECT ~ (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "~#645c7912f3f5/ansi_on", "reason": "SELECT ~ (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/abs.json b/tests/fixtures/analysis/registry-matrix/abs.json index 8e350c477..194bb22b2 100644 --- a/tests/fixtures/analysis/registry-matrix/abs.json +++ b/tests/fixtures/analysis/registry-matrix/abs.json @@ -8,14 +8,6 @@ "id": "abs#23a3b7c1c876/ansi_off", "reason": "SELECT abs(CAST(NULL AS interval year to month)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")" }, - { - "id": "abs#259f8171392f/ansi_on", - "reason": "SELECT abs(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "abs#259f8171392f/ansi_off", - "reason": "SELECT abs(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "abs#5095fc57b734/ansi_on", "reason": "SELECT abs(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/acos.json b/tests/fixtures/analysis/registry-matrix/acos.json index ba719e2b0..675bb51ed 100644 --- a/tests/fixtures/analysis/registry-matrix/acos.json +++ b/tests/fixtures/analysis/registry-matrix/acos.json @@ -8,14 +8,6 @@ "id": "acos#19d853eeed59/ansi_off", "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#646618e3c77a/ansi_on", - "reason": "SELECT acos(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, { "id": "acos#d0cfcf8daa8a/ansi_on", "reason": "SELECT acos(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/acosh.json b/tests/fixtures/analysis/registry-matrix/acosh.json index 2b926735e..9129f2c6c 100644 --- a/tests/fixtures/analysis/registry-matrix/acosh.json +++ b/tests/fixtures/analysis/registry-matrix/acosh.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "acosh#3bee273b22bf/ansi_on", - "reason": "SELECT acosh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, { "id": "acosh#82fdddb3781c/ansi_on", "reason": "SELECT acosh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/add_months.json b/tests/fixtures/analysis/registry-matrix/add_months.json index 5f1ac4979..c6000c0a2 100644 --- a/tests/fixtures/analysis/registry-matrix/add_months.json +++ b/tests/fixtures/analysis/registry-matrix/add_months.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "add_months#22590bd13694/ansi_on", - "reason": "SELECT add_months('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "add_months#22590bd13694/ansi_off", - "reason": "SELECT add_months('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "add_months#244504d3ba66/ansi_on", "reason": "SELECT add_months('2016-08-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -16,14 +8,6 @@ "id": "add_months#244504d3ba66/ansi_off", "reason": "SELECT add_months('2016-08-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "add_months#59aa9c148f08/ansi_on", - "reason": "SELECT add_months(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "add_months#59aa9c148f08/ansi_off", - "reason": "SELECT add_months(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "add_months#5d5156b88671/ansi_on", "reason": "SELECT add_months('2016-08-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/any_value.json b/tests/fixtures/analysis/registry-matrix/any_value.json index 1043b2469..1deb7affd 100644 --- a/tests/fixtures/analysis/registry-matrix/any_value.json +++ b/tests/fixtures/analysis/registry-matrix/any_value.json @@ -8,14 +8,6 @@ "id": "any_value#04ba50b0a41d/ansi_off", "reason": "SELECT any_value(col, INTERVAL '1 02:03:04' DAY TO SECOND) FROM VALUES (NULL), (5), (20) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210" }, - { - "id": "any_value#6188e23671f4/ansi_on", - "reason": "SELECT any_value(col, map('a', 1)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "any_value#6188e23671f4/ansi_off", - "reason": "SELECT any_value(col, map('a', 1)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" - }, { "id": "any_value#ba624a02fb3a/ansi_on", "reason": "SELECT any_value(col, INTERVAL '1-2' YEAR TO MONTH) FROM VALUES (NULL), (5), (20) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210" diff --git a/tests/fixtures/analysis/registry-matrix/array.json b/tests/fixtures/analysis/registry-matrix/array.json index 4ebaa766b..b2a002cf1 100644 --- a/tests/fixtures/analysis/registry-matrix/array.json +++ b/tests/fixtures/analysis/registry-matrix/array.json @@ -16,14 +16,6 @@ "id": "array#3f4eb4621153/ansi_off", "reason": "SELECT array(1, INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "array#48fcc0ee45af/ansi_on", - "reason": "SELECT array(1, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "array#48fcc0ee45af/ansi_off", - "reason": "SELECT array(1, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "array#4e48d4c1b9eb/ansi_on", "reason": "SELECT array(1, 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -40,22 +32,6 @@ "id": "array#56b5cfdc3f32/ansi_off", "reason": "SELECT array(1, INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "array#9cfb954ccb6e/ansi_on", - "reason": "SELECT array(1, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "array#9cfb954ccb6e/ansi_off", - "reason": "SELECT array(1, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "array#bbc3db311e18/ansi_on", - "reason": "SELECT array(map('a', 1), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "array#bbc3db311e18/ansi_off", - "reason": "SELECT array(map('a', 1), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "array#e4bd5d8105fe/ansi_on", "reason": "SELECT array(1, 2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/ascii.json b/tests/fixtures/analysis/registry-matrix/ascii.json index 9fde92f14..28f336dea 100644 --- a/tests/fixtures/analysis/registry-matrix/ascii.json +++ b/tests/fixtures/analysis/registry-matrix/ascii.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "ascii#013ee5ccb991/ansi_on", - "reason": "SELECT ascii(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ascii#013ee5ccb991/ansi_off", - "reason": "SELECT ascii(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ascii#a44ca112e769/ansi_on", "reason": "SELECT ascii(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/asin.json b/tests/fixtures/analysis/registry-matrix/asin.json index 454c57fcf..3441c7f5c 100644 --- a/tests/fixtures/analysis/registry-matrix/asin.json +++ b/tests/fixtures/analysis/registry-matrix/asin.json @@ -15,14 +15,6 @@ { "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" - }, - { - "id": "asin#9782577ff91e/ansi_on", - "reason": "SELECT asin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "asin#9782577ff91e/ansi_off", - "reason": "SELECT asin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/asinh.json b/tests/fixtures/analysis/registry-matrix/asinh.json index b3f4ea37d..fc7b69e08 100644 --- a/tests/fixtures/analysis/registry-matrix/asinh.json +++ b/tests/fixtures/analysis/registry-matrix/asinh.json @@ -8,14 +8,6 @@ "id": "asinh#46c7e19729ea/ansi_off", "reason": "SELECT asinh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "asinh#68bed1327e2a/ansi_on", - "reason": "SELECT asinh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "asinh#68bed1327e2a/ansi_off", - "reason": "SELECT asinh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "asinh#d6f6666c7a87/ansi_on", "reason": "SELECT asinh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/assert_true.json b/tests/fixtures/analysis/registry-matrix/assert_true.json index b94544841..c83653ac0 100644 --- a/tests/fixtures/analysis/registry-matrix/assert_true.json +++ b/tests/fixtures/analysis/registry-matrix/assert_true.json @@ -8,14 +8,6 @@ "id": "assert_true#378e86b90042/ansi_off", "reason": "SELECT assert_true(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "assert_true#9f708e3ccd3a/ansi_on", - "reason": "SELECT assert_true(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "assert_true#9f708e3ccd3a/ansi_off", - "reason": "SELECT assert_true(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "assert_true#ba638b11eda1/ansi_on", "reason": "SELECT assert_true(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/atan.json b/tests/fixtures/analysis/registry-matrix/atan.json index 6489580bb..d3cace8b4 100644 --- a/tests/fixtures/analysis/registry-matrix/atan.json +++ b/tests/fixtures/analysis/registry-matrix/atan.json @@ -15,14 +15,6 @@ { "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" - }, - { - "id": "atan#b9bb1209d291/ansi_on", - "reason": "SELECT atan(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "atan#b9bb1209d291/ansi_off", - "reason": "SELECT atan(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/atan2.json b/tests/fixtures/analysis/registry-matrix/atan2.json index fa66ab9be..94907ab6d 100644 --- a/tests/fixtures/analysis/registry-matrix/atan2.json +++ b/tests/fixtures/analysis/registry-matrix/atan2.json @@ -24,14 +24,6 @@ "id": "atan2#764f8550bc52/ansi_off", "reason": "SELECT atan2(0, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "atan2#99b774404f55/ansi_on", - "reason": "SELECT atan2(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "atan2#99b774404f55/ansi_off", - "reason": "SELECT atan2(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "atan2#b02563140a11/ansi_on", "reason": "SELECT atan2(INTERVAL '1 02:03:04' DAY TO SECOND, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -39,14 +31,6 @@ { "id": "atan2#b02563140a11/ansi_off", "reason": "SELECT atan2(INTERVAL '1 02:03:04' DAY TO SECOND, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#ba98c7f801fa/ansi_off", - "reason": "SELECT atan2(0, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/atanh.json b/tests/fixtures/analysis/registry-matrix/atanh.json index ec5455fa2..f24605935 100644 --- a/tests/fixtures/analysis/registry-matrix/atanh.json +++ b/tests/fixtures/analysis/registry-matrix/atanh.json @@ -8,14 +8,6 @@ "id": "atanh#15554836e9c9/ansi_off", "reason": "SELECT atanh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "atanh#42a8da352d6f/ansi_on", - "reason": "SELECT atanh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "atanh#42a8da352d6f/ansi_off", - "reason": "SELECT atanh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "atanh#8aee7e3f3cdc/ansi_on", "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" diff --git a/tests/fixtures/analysis/registry-matrix/base64.json b/tests/fixtures/analysis/registry-matrix/base64.json index bb00858bd..1a50b5a07 100644 --- a/tests/fixtures/analysis/registry-matrix/base64.json +++ b/tests/fixtures/analysis/registry-matrix/base64.json @@ -8,14 +8,6 @@ "id": "base64#1ed5a9f8660a/ansi_off", "reason": "SELECT base64(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "base64#c00dc50d3002/ansi_on", - "reason": "SELECT base64(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "base64#c00dc50d3002/ansi_off", - "reason": "SELECT base64(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "base64#e37858a48b28/ansi_on", "reason": "SELECT base64(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/bin.json b/tests/fixtures/analysis/registry-matrix/bin.json index b914b888c..f3108b74a 100644 --- a/tests/fixtures/analysis/registry-matrix/bin.json +++ b/tests/fixtures/analysis/registry-matrix/bin.json @@ -8,14 +8,6 @@ "id": "bin#26e5da0cb603/ansi_off", "reason": "SELECT bin(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "bin#4cd5b0b8f41e/ansi_on", - "reason": "SELECT bin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bin#4cd5b0b8f41e/ansi_off", - "reason": "SELECT bin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "bin#a90cb066faf8/ansi_on", "reason": "SELECT bin(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/bit_count.json b/tests/fixtures/analysis/registry-matrix/bit_count.json index f4aeb3908..57c9a16fa 100644 --- a/tests/fixtures/analysis/registry-matrix/bit_count.json +++ b/tests/fixtures/analysis/registry-matrix/bit_count.json @@ -8,14 +8,6 @@ "id": "bit_count#3c6cb8a6494d/ansi_off", "reason": "SELECT bit_count(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "bit_count#aaeec33f89a8/ansi_on", - "reason": "SELECT bit_count(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bit_count#aaeec33f89a8/ansi_off", - "reason": "SELECT bit_count(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "bit_count#b49e21523e6e/ansi_on", "reason": "SELECT bit_count(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/bit_get.json b/tests/fixtures/analysis/registry-matrix/bit_get.json index 097128403..a8c92860f 100644 --- a/tests/fixtures/analysis/registry-matrix/bit_get.json +++ b/tests/fixtures/analysis/registry-matrix/bit_get.json @@ -24,22 +24,6 @@ "id": "bit_get#6a2359118785/ansi_off", "reason": "SELECT bit_get(INTERVAL '1 02:03:04' DAY TO SECOND, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "bit_get#9e9ba98e7b02/ansi_on", - "reason": "SELECT bit_get(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bit_get#9e9ba98e7b02/ansi_off", - "reason": "SELECT bit_get(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bit_get#ce44b5105527/ansi_on", - "reason": "SELECT bit_get(11, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bit_get#ce44b5105527/ansi_off", - "reason": "SELECT bit_get(11, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "bit_get#d65837d86911/ansi_on", "reason": "SELECT bit_get(11, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/bit_length.json b/tests/fixtures/analysis/registry-matrix/bit_length.json index 1133bf35d..02dfaab27 100644 --- a/tests/fixtures/analysis/registry-matrix/bit_length.json +++ b/tests/fixtures/analysis/registry-matrix/bit_length.json @@ -8,14 +8,6 @@ "id": "bit_length#79fe889112dd/ansi_off", "reason": "SELECT bit_length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "bit_length#9e485b176014/ansi_on", - "reason": "SELECT bit_length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bit_length#9e485b176014/ansi_off", - "reason": "SELECT bit_length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "bit_length#f869a613120a/ansi_on", "reason": "SELECT bit_length(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/bround.json b/tests/fixtures/analysis/registry-matrix/bround.json index 8b729761a..81d5a0836 100644 --- a/tests/fixtures/analysis/registry-matrix/bround.json +++ b/tests/fixtures/analysis/registry-matrix/bround.json @@ -8,14 +8,6 @@ "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" }, - { - "id": "bround#18b5217d3eff/ansi_on", - "reason": "SELECT bround(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bround#18b5217d3eff/ansi_off", - "reason": "SELECT bround(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "bround#8139bd9fdb4c/ansi_on", "reason": "SELECT bround(2.5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -39,14 +31,6 @@ { "id": "bround#972098065b06/ansi_off", "reason": "SELECT bround(2.5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bround#e536627ae66a/ansi_on", - "reason": "SELECT bround(2.5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/btrim.json b/tests/fixtures/analysis/registry-matrix/btrim.json index 0f75beb13..7efb9c872 100644 --- a/tests/fixtures/analysis/registry-matrix/btrim.json +++ b/tests/fixtures/analysis/registry-matrix/btrim.json @@ -1,21 +1,5 @@ { "entries": [ - { - "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#02142a9cc3f9/ansi_off", - "reason": "SELECT btrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#08b197e99878/ansi_off", - "reason": "SELECT btrim(map('a', 1), 'SL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "btrim#49205ad1c50a/ansi_on", "reason": "SELECT btrim(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -32,14 +16,6 @@ "id": "btrim#5a1a560c70c8/ansi_off", "reason": "SELECT btrim(INTERVAL '1 02:03:04' DAY TO SECOND, 'SL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "btrim#812b69ba8fda/ansi_on", - "reason": "SELECT btrim('SSparkSQLS', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "btrim#812b69ba8fda/ansi_off", - "reason": "SELECT btrim('SSparkSQLS', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "btrim#a36287350867/ansi_on", "reason": "SELECT btrim(INTERVAL '1-2' YEAR TO MONTH, 'SL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/cbrt.json b/tests/fixtures/analysis/registry-matrix/cbrt.json index c66e34d42..49e0484dc 100644 --- a/tests/fixtures/analysis/registry-matrix/cbrt.json +++ b/tests/fixtures/analysis/registry-matrix/cbrt.json @@ -8,14 +8,6 @@ "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" }, - { - "id": "cbrt#73c4fc1e92b9/ansi_on", - "reason": "SELECT cbrt(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "cbrt#73c4fc1e92b9/ansi_off", - "reason": "SELECT cbrt(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "cbrt#fdb007bf9143/ansi_on", "reason": "SELECT cbrt(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/ceil.json b/tests/fixtures/analysis/registry-matrix/ceil.json index 5f181e547..b14b9cab1 100644 --- a/tests/fixtures/analysis/registry-matrix/ceil.json +++ b/tests/fixtures/analysis/registry-matrix/ceil.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "ceil#4ca9bc16d90d/ansi_on", - "reason": "SELECT ceil(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ceil#4ca9bc16d90d/ansi_off", - "reason": "SELECT ceil(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "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" @@ -16,14 +8,6 @@ "id": "ceil#4dce47b6e5a6/ansi_off", "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#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#5b3a37a449f4/ansi_off", - "reason": "SELECT ceil(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ceil#bb23a5bd68bf/ansi_on", "reason": "SELECT ceil(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -63,14 +47,6 @@ { "id": "ceil#ed407430737b/ansi_off", "reason": "SELECT ceil(3.1411, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has NON_FOLDABLE_ARGUMENT" - }, - { - "id": "ceil#ef22c7d14e9b/ansi_on", - "reason": "SELECT ceil(3.1411, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has NON_FOLDABLE_ARGUMENT" - }, - { - "id": "ceil#ef22c7d14e9b/ansi_off", - "reason": "SELECT ceil(3.1411, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has NON_FOLDABLE_ARGUMENT" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/ceiling.json b/tests/fixtures/analysis/registry-matrix/ceiling.json index a55a9367c..c198fd26d 100644 --- a/tests/fixtures/analysis/registry-matrix/ceiling.json +++ b/tests/fixtures/analysis/registry-matrix/ceiling.json @@ -8,14 +8,6 @@ "id": "ceiling#3d5f6ac925b9/ansi_off", "reason": "SELECT ceiling(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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#523bf03f299a/ansi_off", - "reason": "SELECT ceiling(3.1411, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has NON_FOLDABLE_ARGUMENT" - }, { "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" @@ -32,14 +24,6 @@ "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" }, - { - "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#a881960ea852/ansi_off", - "reason": "SELECT ceiling(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "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" @@ -48,14 +32,6 @@ "id": "ceiling#c2037689a057/ansi_off", "reason": "SELECT ceiling(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "ceiling#f4a8508a15c7/ansi_on", - "reason": "SELECT ceiling(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ceiling#f4a8508a15c7/ansi_off", - "reason": "SELECT ceiling(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ceiling#f4f85323d8de/ansi_on", "reason": "SELECT ceiling(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/char.json b/tests/fixtures/analysis/registry-matrix/char.json index 8320612b7..bab659a1a 100644 --- a/tests/fixtures/analysis/registry-matrix/char.json +++ b/tests/fixtures/analysis/registry-matrix/char.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "char#32ad6e52db6c/ansi_on", - "reason": "SELECT char(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "char#32ad6e52db6c/ansi_off", - "reason": "SELECT char(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "char#b3341cf35c8e/ansi_on", "reason": "SELECT char(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/char_length.json b/tests/fixtures/analysis/registry-matrix/char_length.json index f8ba9cbbf..37117c118 100644 --- a/tests/fixtures/analysis/registry-matrix/char_length.json +++ b/tests/fixtures/analysis/registry-matrix/char_length.json @@ -8,14 +8,6 @@ "id": "char_length#1239bea4a1a4/ansi_off", "reason": "SELECT char_length(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "char_length#51c55d351a74/ansi_on", - "reason": "SELECT char_length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "char_length#51c55d351a74/ansi_off", - "reason": "SELECT char_length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "char_length#f6d2d8a18a6b/ansi_on", "reason": "SELECT char_length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/character_length.json b/tests/fixtures/analysis/registry-matrix/character_length.json index b53efa045..ec1a9a397 100644 --- a/tests/fixtures/analysis/registry-matrix/character_length.json +++ b/tests/fixtures/analysis/registry-matrix/character_length.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "character_length#56e93b4b33b9/ansi_on", - "reason": "SELECT character_length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "character_length#56e93b4b33b9/ansi_off", - "reason": "SELECT character_length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "character_length#630819a954e3/ansi_on", "reason": "SELECT character_length(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/chr.json b/tests/fixtures/analysis/registry-matrix/chr.json index 9a01e2b87..944d833e3 100644 --- a/tests/fixtures/analysis/registry-matrix/chr.json +++ b/tests/fixtures/analysis/registry-matrix/chr.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "chr#701f944ff7a9/ansi_on", - "reason": "SELECT chr(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "chr#701f944ff7a9/ansi_off", - "reason": "SELECT chr(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "chr#986aa06a93b7/ansi_on", "reason": "SELECT chr(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/coalesce.json b/tests/fixtures/analysis/registry-matrix/coalesce.json index 2586d0eb0..8b733eb7e 100644 --- a/tests/fixtures/analysis/registry-matrix/coalesce.json +++ b/tests/fixtures/analysis/registry-matrix/coalesce.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "coalesce#14f80f6e45b3/ansi_on", - "reason": "SELECT coalesce(NULL, map('a', 1), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "coalesce#14f80f6e45b3/ansi_off", - "reason": "SELECT coalesce(NULL, map('a', 1), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, { "id": "coalesce#31842a9dbd4d/ansi_on", "reason": "SELECT coalesce(NULL, INTERVAL '1 02:03:04' DAY TO SECOND, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -16,22 +8,6 @@ "id": "coalesce#31842a9dbd4d/ansi_off", "reason": "SELECT coalesce(NULL, INTERVAL '1 02:03:04' DAY TO SECOND, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "coalesce#58920259386f/ansi_on", - "reason": "SELECT coalesce(map('a', 1), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "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" - }, - { - "id": "coalesce#610f56497531/ansi_on", - "reason": "SELECT coalesce(NULL, 1, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "coalesce#610f56497531/ansi_off", - "reason": "SELECT coalesce(NULL, 1, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "coalesce#6790aeb96831/ansi_on", "reason": "SELECT coalesce(NULL, INTERVAL '1-2' YEAR TO MONTH, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/concat_ws.json b/tests/fixtures/analysis/registry-matrix/concat_ws.json index 4ba5b01d0..d64fe1bb1 100644 --- a/tests/fixtures/analysis/registry-matrix/concat_ws.json +++ b/tests/fixtures/analysis/registry-matrix/concat_ws.json @@ -32,14 +32,6 @@ "id": "concat_ws#1ef4e877d67c/ansi_off", "reason": "SELECT concat_ws(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "concat_ws#22d2f586784a/ansi_on", - "reason": "SELECT concat_ws(map('a', 1), 'foo', null, 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#22d2f586784a/ansi_off", - "reason": "SELECT concat_ws(map('a', 1), 'foo', null, 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "concat_ws#2329ae0c9685/ansi_on", "reason": "SELECT concat_ws('/', INTERVAL '1-2' YEAR TO MONTH, null, 'bar') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -72,14 +64,6 @@ "id": "concat_ws#2616ec8f1364/ansi_off", "reason": "SELECT concat_ws(INTERVAL '1 02:03:04' DAY TO SECOND, 'foo', null, 'bar') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "concat_ws#32981df856c0/ansi_on", - "reason": "SELECT concat_ws(' ', 'Spark', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#32981df856c0/ansi_off", - "reason": "SELECT concat_ws(' ', 'Spark', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "concat_ws#36558275390c/ansi_on", "reason": "SELECT concat_ws(' ', INTERVAL '1 02:03:04' DAY TO SECOND, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -96,14 +80,6 @@ "id": "concat_ws#4a51a9f372e8/ansi_off", "reason": "SELECT concat_ws('/', 'foo', INTERVAL '1 02:03:04' DAY TO SECOND, 'bar') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "concat_ws#573a38ae815d/ansi_on", - "reason": "SELECT concat_ws(' ', map('a', 1), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#573a38ae815d/ansi_off", - "reason": "SELECT concat_ws(' ', map('a', 1), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "concat_ws#69a864969151/ansi_on", "reason": "SELECT concat_ws(' ', 'Spark', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -120,38 +96,6 @@ "id": "concat_ws#6ab0510eaa1f/ansi_off", "reason": "SELECT concat_ws(INTERVAL '1 02:03:04' DAY TO SECOND, 'Spark', 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "concat_ws#7029d64723a3/ansi_on", - "reason": "SELECT concat_ws('/', 'foo', map('a', 1), 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#7029d64723a3/ansi_off", - "reason": "SELECT concat_ws('/', 'foo', map('a', 1), 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#7addaa8317aa/ansi_on", - "reason": "SELECT concat_ws(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#7addaa8317aa/ansi_off", - "reason": "SELECT concat_ws(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#92f099d09cb2/ansi_on", - "reason": "SELECT concat_ws('/', 'foo', null, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#92f099d09cb2/ansi_off", - "reason": "SELECT concat_ws('/', 'foo', null, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#9c2e8119ee7e/ansi_on", - "reason": "SELECT concat_ws('/', map('a', 1), null, 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#9c2e8119ee7e/ansi_off", - "reason": "SELECT concat_ws('/', map('a', 1), null, 'bar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "concat_ws#a2d9986c591d/ansi_on", "reason": "SELECT concat_ws('/', 'foo', null, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -184,14 +128,6 @@ "id": "concat_ws#bbb2b8b9fa31/ansi_off", "reason": "SELECT concat_ws(' ', 'Spark', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "concat_ws#bf2fe2a2984d/ansi_on", - "reason": "SELECT concat_ws(map('a', 1), 'Spark', 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "concat_ws#bf2fe2a2984d/ansi_off", - "reason": "SELECT concat_ws(map('a', 1), 'Spark', 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "concat_ws#d0d1514cd7ab/ansi_on", "reason": "SELECT concat_ws(INTERVAL '1-2' YEAR TO MONTH, 'foo', null, 'bar') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/contains.json b/tests/fixtures/analysis/registry-matrix/contains.json index 70fef4f2b..6216050f1 100644 --- a/tests/fixtures/analysis/registry-matrix/contains.json +++ b/tests/fixtures/analysis/registry-matrix/contains.json @@ -1,13 +1,5 @@ { "entries": [ - { - "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#1399b878e567/ansi_off", - "reason": "SELECT contains('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "contains#4b1b8fa21e9e/ansi_on", "reason": "SELECT contains(INTERVAL '1 02:03:04' DAY TO SECOND, 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -39,14 +31,6 @@ { "id": "contains#d7f2b5dd724d/ansi_off", "reason": "SELECT contains('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "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#ebccf89c15c8/ansi_off", - "reason": "SELECT contains(map('a', 1), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/conv.json b/tests/fixtures/analysis/registry-matrix/conv.json index 5c4f63d72..cb92231e1 100644 --- a/tests/fixtures/analysis/registry-matrix/conv.json +++ b/tests/fixtures/analysis/registry-matrix/conv.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "conv#2fc4a1cce6e3/ansi_on", - "reason": "SELECT conv('100', 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "conv#2fc4a1cce6e3/ansi_off", - "reason": "SELECT conv('100', 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "conv#7461c93e555c/ansi_on", "reason": "SELECT conv(INTERVAL '1 02:03:04' DAY TO SECOND, 2, 10) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -32,14 +24,6 @@ "id": "conv#83889cba804a/ansi_off", "reason": "SELECT conv(INTERVAL '1-2' YEAR TO MONTH, 2, 10) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "conv#847e4eeb237e/ansi_on", - "reason": "SELECT conv('100', map('a', 1), 10) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "conv#847e4eeb237e/ansi_off", - "reason": "SELECT conv('100', map('a', 1), 10) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "conv#921f200c75eb/ansi_on", "reason": "SELECT conv('100', INTERVAL '1 02:03:04' DAY TO SECOND, 10) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -63,14 +47,6 @@ { "id": "conv#bb384aabc1fa/ansi_off", "reason": "SELECT conv('100', 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "conv#c45bee861796/ansi_on", - "reason": "SELECT conv(map('a', 1), 2, 10) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "conv#c45bee861796/ansi_off", - "reason": "SELECT conv(map('a', 1), 2, 10) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/convert_timezone.json b/tests/fixtures/analysis/registry-matrix/convert_timezone.json index c55a4b9e5..19bc61efe 100644 --- a/tests/fixtures/analysis/registry-matrix/convert_timezone.json +++ b/tests/fixtures/analysis/registry-matrix/convert_timezone.json @@ -40,14 +40,6 @@ "id": "convert_timezone#4b75798678ba/ansi_off", "reason": "SELECT convert_timezone('Europe/Brussels', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "convert_timezone#5a82d191b61f/ansi_on", - "reason": "SELECT convert_timezone(map('a', 1), timestamp_ntz'2021-12-05 15:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#5a82d191b61f/ansi_off", - "reason": "SELECT convert_timezone(map('a', 1), timestamp_ntz'2021-12-05 15:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "convert_timezone#7fa8f7d4a0f7/ansi_on", "reason": "SELECT convert_timezone(INTERVAL '1 02:03:04' DAY TO SECOND, timestamp_ntz'2021-12-05 15:00:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -56,38 +48,6 @@ "id": "convert_timezone#7fa8f7d4a0f7/ansi_off", "reason": "SELECT convert_timezone(INTERVAL '1 02:03:04' DAY TO SECOND, timestamp_ntz'2021-12-05 15:00:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "convert_timezone#80c118abe0f9/ansi_on", - "reason": "SELECT convert_timezone('Europe/Brussels', map('a', 1), timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#80c118abe0f9/ansi_off", - "reason": "SELECT convert_timezone('Europe/Brussels', map('a', 1), timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#9cd512e9f190/ansi_on", - "reason": "SELECT convert_timezone('Europe/Brussels', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#9cd512e9f190/ansi_off", - "reason": "SELECT convert_timezone('Europe/Brussels', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#a0fd4b8c0308/ansi_on", - "reason": "SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#a0fd4b8c0308/ansi_off", - "reason": "SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#a14ce4fcad56/ansi_on", - "reason": "SELECT convert_timezone(map('a', 1), 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#a14ce4fcad56/ansi_off", - "reason": "SELECT convert_timezone(map('a', 1), 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "convert_timezone#b0dd48f6ba13/ansi_on", "reason": "SELECT convert_timezone('Europe/Brussels', INTERVAL '1-2' YEAR TO MONTH, timestamp_ntz'2021-12-06 00:00:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/cos.json b/tests/fixtures/analysis/registry-matrix/cos.json index 4fd04dff5..74f8c2a37 100644 --- a/tests/fixtures/analysis/registry-matrix/cos.json +++ b/tests/fixtures/analysis/registry-matrix/cos.json @@ -15,14 +15,6 @@ { "id": "cos#26a1dc09a534/ansi_off", "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#6e49e17c44c6/ansi_on", - "reason": "SELECT cos(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "cos#6e49e17c44c6/ansi_off", - "reason": "SELECT cos(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/cosh.json b/tests/fixtures/analysis/registry-matrix/cosh.json index 210f6f7d7..9dc2bafd9 100644 --- a/tests/fixtures/analysis/registry-matrix/cosh.json +++ b/tests/fixtures/analysis/registry-matrix/cosh.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "cosh#19241e43181f/ansi_on", - "reason": "SELECT cosh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "cosh#19241e43181f/ansi_off", - "reason": "SELECT cosh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "cosh#43b9893c0613/ansi_on", "reason": "SELECT cosh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/cot.json b/tests/fixtures/analysis/registry-matrix/cot.json index a319e5ced..3cfce442b 100644 --- a/tests/fixtures/analysis/registry-matrix/cot.json +++ b/tests/fixtures/analysis/registry-matrix/cot.json @@ -8,14 +8,6 @@ "id": "cot#8ce11c7a7b63/ansi_off", "reason": "SELECT cot(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "cot#d332d357b677/ansi_on", - "reason": "SELECT cot(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "cot#d332d357b677/ansi_off", - "reason": "SELECT cot(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "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" diff --git a/tests/fixtures/analysis/registry-matrix/crc32.json b/tests/fixtures/analysis/registry-matrix/crc32.json index 2a65153c9..94c246fae 100644 --- a/tests/fixtures/analysis/registry-matrix/crc32.json +++ b/tests/fixtures/analysis/registry-matrix/crc32.json @@ -15,14 +15,6 @@ { "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" - }, - { - "id": "crc32#71d86ae74897/ansi_on", - "reason": "SELECT crc32(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "crc32#71d86ae74897/ansi_off", - "reason": "SELECT crc32(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/csc.json b/tests/fixtures/analysis/registry-matrix/csc.json index a8b6d1baa..030e2218b 100644 --- a/tests/fixtures/analysis/registry-matrix/csc.json +++ b/tests/fixtures/analysis/registry-matrix/csc.json @@ -1,13 +1,5 @@ { "entries": [ - { - "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_off", - "reason": "SELECT csc(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "csc#9a00661998eb/ansi_on", "reason": "SELECT csc(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/date_add.json b/tests/fixtures/analysis/registry-matrix/date_add.json index 245c2a5d9..83b4fe349 100644 --- a/tests/fixtures/analysis/registry-matrix/date_add.json +++ b/tests/fixtures/analysis/registry-matrix/date_add.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "date_add#2870a363da2b/ansi_on", - "reason": "SELECT date_add('2016-07-30', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, { "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" @@ -16,14 +8,6 @@ "id": "date_add#3bdf7ada3e68/ansi_off", "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#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#925969f2424a/ansi_off", - "reason": "SELECT date_add(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_add#a2161f5ef3fc/ansi_on", "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" diff --git a/tests/fixtures/analysis/registry-matrix/date_diff.json b/tests/fixtures/analysis/registry-matrix/date_diff.json index a3ae33668..b599d1c56 100644 --- a/tests/fixtures/analysis/registry-matrix/date_diff.json +++ b/tests/fixtures/analysis/registry-matrix/date_diff.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "date_diff#05942e933fcc/ansi_on", - "reason": "SELECT date_diff(map('a', 1), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_diff#05942e933fcc/ansi_off", - "reason": "SELECT date_diff(map('a', 1), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_diff#13970b9a8111/ansi_on", "reason": "SELECT date_diff(INTERVAL '1-2' YEAR TO MONTH, '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "date_diff#551ef3d9f510/ansi_off", "reason": "SELECT date_diff('2009-07-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_diff#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#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" - }, { "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" diff --git a/tests/fixtures/analysis/registry-matrix/date_part.json b/tests/fixtures/analysis/registry-matrix/date_part.json index 062179a6f..751dcfaa0 100644 --- a/tests/fixtures/analysis/registry-matrix/date_part.json +++ b/tests/fixtures/analysis/registry-matrix/date_part.json @@ -10,11 +10,11 @@ }, { "id": "date_part#0a4ee947f0cd/ansi_on", - "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" + "reason": "SELECT date_part(map('a', 1), TIMESTAMP '2019-08-12 01:00:00.123456') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has NON_FOLDABLE_ARGUMENT" }, { "id": "date_part#0a4ee947f0cd/ansi_off", - "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" + "reason": "SELECT date_part(map('a', 1), TIMESTAMP '2019-08-12 01:00:00.123456') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has NON_FOLDABLE_ARGUMENT" }, { "id": "date_part#186144d07620/ansi_on", @@ -24,14 +24,6 @@ "id": "date_part#186144d07620/ansi_off", "reason": "SELECT date_part(named_struct('a', 1, 'b', 'x'), TIMESTAMP '2019-08-12 01:00:00.123456') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has NON_FOLDABLE_ARGUMENT" }, - { - "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#2d8e71c6a7e2/ansi_off", - "reason": "SELECT date_part('YEAR', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "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\")" diff --git a/tests/fixtures/analysis/registry-matrix/date_sub.json b/tests/fixtures/analysis/registry-matrix/date_sub.json index 729bec07e..53614b72f 100644 --- a/tests/fixtures/analysis/registry-matrix/date_sub.json +++ b/tests/fixtures/analysis/registry-matrix/date_sub.json @@ -8,14 +8,6 @@ "id": "date_sub#71cca371ad5a/ansi_off", "reason": "SELECT date_sub('2016-07-30', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_sub#adae19b649ad/ansi_on", - "reason": "SELECT date_sub(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_sub#adae19b649ad/ansi_off", - "reason": "SELECT date_sub(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_sub#b39d32775713/ansi_on", "reason": "SELECT date_sub(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -39,14 +31,6 @@ { "id": "date_sub#f11afe47f79b/ansi_off", "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#f67743ec255a/ansi_on", - "reason": "SELECT date_sub('2016-07-30', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/date_trunc.json b/tests/fixtures/analysis/registry-matrix/date_trunc.json index aee9b50b5..9e4e58691 100644 --- a/tests/fixtures/analysis/registry-matrix/date_trunc.json +++ b/tests/fixtures/analysis/registry-matrix/date_trunc.json @@ -16,14 +16,6 @@ "id": "date_trunc#667578cd1810/ansi_off", "reason": "SELECT date_trunc('YEAR', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_trunc#ab8944d5b81e/ansi_on", - "reason": "SELECT date_trunc(map('a', 1), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_trunc#ab8944d5b81e/ansi_off", - "reason": "SELECT date_trunc(map('a', 1), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_trunc#bbab69ebe047/ansi_on", "reason": "SELECT date_trunc(INTERVAL '1 02:03:04' DAY TO SECOND, '2015-03-05T09:32:05.359') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -32,14 +24,6 @@ "id": "date_trunc#bbab69ebe047/ansi_off", "reason": "SELECT date_trunc(INTERVAL '1 02:03:04' DAY TO SECOND, '2015-03-05T09:32:05.359') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "date_trunc#ce274ba1d399/ansi_on", - "reason": "SELECT date_trunc('YEAR', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_trunc#ce274ba1d399/ansi_off", - "reason": "SELECT date_trunc('YEAR', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_trunc#de483f214493/ansi_on", "reason": "SELECT date_trunc(INTERVAL '1-2' YEAR TO MONTH, '2015-03-05T09:32:05.359') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/dateadd.json b/tests/fixtures/analysis/registry-matrix/dateadd.json index 361aa2aae..5dbf24109 100644 --- a/tests/fixtures/analysis/registry-matrix/dateadd.json +++ b/tests/fixtures/analysis/registry-matrix/dateadd.json @@ -31,22 +31,6 @@ { "id": "dateadd#c764c8e633d8/ansi_off", "reason": "SELECT dateadd('2016-07-30', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#f04884c6faf2/ansi_off", - "reason": "SELECT dateadd(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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": "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" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/datediff.json b/tests/fixtures/analysis/registry-matrix/datediff.json index 854813384..7b4f45c79 100644 --- a/tests/fixtures/analysis/registry-matrix/datediff.json +++ b/tests/fixtures/analysis/registry-matrix/datediff.json @@ -8,22 +8,6 @@ "id": "datediff#1ada08a843e8/ansi_off", "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#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#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" - }, - { - "id": "datediff#4657e613fe6c/ansi_on", - "reason": "SELECT datediff(map('a', 1), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "datediff#4657e613fe6c/ansi_off", - "reason": "SELECT datediff(map('a', 1), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "datediff#4ae76939f035/ansi_on", "reason": "SELECT datediff('2009-07-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/day.json b/tests/fixtures/analysis/registry-matrix/day.json index 91c8a1913..66d77ff44 100644 --- a/tests/fixtures/analysis/registry-matrix/day.json +++ b/tests/fixtures/analysis/registry-matrix/day.json @@ -8,14 +8,6 @@ "id": "day#c5006e6a3413/ansi_off", "reason": "SELECT day(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "day#cfc2b8babc14/ansi_on", - "reason": "SELECT day(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "day#cfc2b8babc14/ansi_off", - "reason": "SELECT day(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "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" diff --git a/tests/fixtures/analysis/registry-matrix/dayname.json b/tests/fixtures/analysis/registry-matrix/dayname.json index d39bc58de..2c5963875 100644 --- a/tests/fixtures/analysis/registry-matrix/dayname.json +++ b/tests/fixtures/analysis/registry-matrix/dayname.json @@ -8,14 +8,6 @@ "id": "dayname#403761638cd0/ansi_off", "reason": "SELECT dayname(DATE('2008-02-20')) | KRISHIV_UNSUPPORTED_FEATURE: function DATE" }, - { - "id": "dayname#625530e0b739/ansi_on", - "reason": "SELECT dayname(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dayname#625530e0b739/ansi_off", - "reason": "SELECT dayname(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "dayname#8626b306f794/ansi_on", "reason": "SELECT dayname(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/dayofmonth.json b/tests/fixtures/analysis/registry-matrix/dayofmonth.json index 4f48188c2..e4c8c6396 100644 --- a/tests/fixtures/analysis/registry-matrix/dayofmonth.json +++ b/tests/fixtures/analysis/registry-matrix/dayofmonth.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "dayofmonth#0296012a73bf/ansi_on", - "reason": "SELECT dayofmonth(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dayofmonth#0296012a73bf/ansi_off", - "reason": "SELECT dayofmonth(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "dayofmonth#63cbd5ac0445/ansi_on", "reason": "SELECT dayofmonth(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/dayofweek.json b/tests/fixtures/analysis/registry-matrix/dayofweek.json index b68dc7720..c1b21e530 100644 --- a/tests/fixtures/analysis/registry-matrix/dayofweek.json +++ b/tests/fixtures/analysis/registry-matrix/dayofweek.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "dayofweek#1cb766f4a670/ansi_on", - "reason": "SELECT dayofweek(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dayofweek#1cb766f4a670/ansi_off", - "reason": "SELECT dayofweek(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "dayofweek#47b613bea55d/ansi_on", "reason": "SELECT dayofweek(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/dayofyear.json b/tests/fixtures/analysis/registry-matrix/dayofyear.json index 91b7dee02..2117db23d 100644 --- a/tests/fixtures/analysis/registry-matrix/dayofyear.json +++ b/tests/fixtures/analysis/registry-matrix/dayofyear.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "dayofyear#8545d9aa0c51/ansi_on", - "reason": "SELECT dayofyear(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dayofyear#8545d9aa0c51/ansi_off", - "reason": "SELECT dayofyear(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "dayofyear#e8a838e4f908/ansi_on", "reason": "SELECT dayofyear(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/decode.json b/tests/fixtures/analysis/registry-matrix/decode.json index 05df015f1..b928b39a7 100644 --- a/tests/fixtures/analysis/registry-matrix/decode.json +++ b/tests/fixtures/analysis/registry-matrix/decode.json @@ -330,11 +330,11 @@ }, { "id": "decode#0f86e9c46963/ansi_on", - "reason": "SELECT decode(null, 6, 'Spark', map('a', 1), 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" + "reason": "SELECT decode(null, 6, 'Spark', map('a', 1), 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" }, { "id": "decode#0f86e9c46963/ansi_off", - "reason": "SELECT decode(null, 6, 'Spark', map('a', 1), 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" + "reason": "SELECT decode(null, 6, 'Spark', map('a', 1), 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" }, { "id": "decode#0f9cc861dcda/ansi_on", @@ -1226,11 +1226,11 @@ }, { "id": "decode#3d0118850746/ansi_on", - "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', map('a', 1), 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', map('a', 1), 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#3d0118850746/ansi_off", - "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', map('a', 1), 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', map('a', 1), 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#3d2c5dcb0c48/ansi_on", @@ -1530,11 +1530,11 @@ }, { "id": "decode#4be08f9fd301/ansi_on", - "reason": "SELECT decode(6, map('a', 1), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(6, map('a', 1), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#4be08f9fd301/ansi_off", - "reason": "SELECT decode(6, map('a', 1), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(6, map('a', 1), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#4be2c9e0da9a/ansi_on", @@ -1570,11 +1570,11 @@ }, { "id": "decode#4e15a144b017/ansi_on", - "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', map('a', 1), 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', map('a', 1), 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#4e15a144b017/ansi_off", - "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', map('a', 1), 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', map('a', 1), 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#4e57a91e7452/ansi_on", @@ -1594,11 +1594,11 @@ }, { "id": "decode#4f1a99220603/ansi_on", - "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', map('a', 1), 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', map('a', 1), 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#4f1a99220603/ansi_off", - "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', map('a', 1), 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', map('a', 1), 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#4f80cad44f29/ansi_on", @@ -2042,11 +2042,11 @@ }, { "id": "decode#6319fadc314b/ansi_on", - "reason": "SELECT decode(2, map('a', 1), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(2, map('a', 1), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#6319fadc314b/ansi_off", - "reason": "SELECT decode(2, map('a', 1), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(2, map('a', 1), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#632b1e830f5a/ansi_on", @@ -2178,11 +2178,11 @@ }, { "id": "decode#690020fa5f12/ansi_on", - "reason": "SELECT decode(6, 1, 'Southlake', 2, map('a', 1), 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', 2, map('a', 1), 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#690020fa5f12/ansi_off", - "reason": "SELECT decode(6, 1, 'Southlake', 2, map('a', 1), 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', 2, map('a', 1), 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#6a24da7418d4/ansi_on", @@ -2642,11 +2642,11 @@ }, { "id": "decode#83c6f13b22a4/ansi_on", - "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, map('a', 1), 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, map('a', 1), 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#83c6f13b22a4/ansi_off", - "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, map('a', 1), 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, map('a', 1), 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#8462c37f4e90/ansi_on", @@ -2722,11 +2722,11 @@ }, { "id": "decode#87bc55fdb57f/ansi_on", - "reason": "SELECT decode(null, map('a', 1), 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" + "reason": "SELECT decode(null, map('a', 1), 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" }, { "id": "decode#87bc55fdb57f/ansi_off", - "reason": "SELECT decode(null, map('a', 1), 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" + "reason": "SELECT decode(null, map('a', 1), 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" }, { "id": "decode#87f059066368/ansi_on", @@ -2842,11 +2842,11 @@ }, { "id": "decode#8f8146d1b472/ansi_on", - "reason": "SELECT decode(2, 1, 'Southlake', 2, map('a', 1), 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, map('a', 1), 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#8f8146d1b472/ansi_off", - "reason": "SELECT decode(2, 1, 'Southlake', 2, map('a', 1), 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, map('a', 1), 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#8f8165ce354f/ansi_on", @@ -2938,11 +2938,11 @@ }, { "id": "decode#93ace2b30a48/ansi_on", - "reason": "SELECT decode(6, 1, map('a', 1), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(6, 1, map('a', 1), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#93ace2b30a48/ansi_off", - "reason": "SELECT decode(6, 1, map('a', 1), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(6, 1, map('a', 1), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#93f3ec141054/ansi_on", @@ -3066,27 +3066,27 @@ }, { "id": "decode#99da120b58dc/ansi_on", - "reason": "SELECT decode(map('a', 1), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(map('a', 1), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#99da120b58dc/ansi_off", - "reason": "SELECT decode(map('a', 1), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(map('a', 1), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#9a0622bb45c8/ansi_on", - "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#9a0622bb45c8/ansi_off", - "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#9a890e0f04e0/ansi_on", - "reason": "SELECT decode(2, 1, 'Southlake', map('a', 1), 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', map('a', 1), 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#9a890e0f04e0/ansi_off", - "reason": "SELECT decode(2, 1, 'Southlake', map('a', 1), 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', map('a', 1), 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#9a977b64470d/ansi_on", @@ -3130,11 +3130,11 @@ }, { "id": "decode#9c6fbabadfd7/ansi_on", - "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#9c6fbabadfd7/ansi_off", - "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#9cbdc46e955d/ansi_on", @@ -3434,11 +3434,11 @@ }, { "id": "decode#af23fef8e9f1/ansi_on", - "reason": "SELECT decode(2, 1, map('a', 1), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(2, 1, map('a', 1), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#af23fef8e9f1/ansi_off", - "reason": "SELECT decode(2, 1, map('a', 1), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(2, 1, map('a', 1), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#af3e58cade43/ansi_on", @@ -3458,11 +3458,11 @@ }, { "id": "decode#afedaefd3247/ansi_on", - "reason": "SELECT decode(null, 6, 'Spark', NULL, map('a', 1), 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(null, 6, 'Spark', NULL, map('a', 1), 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#afedaefd3247/ansi_off", - "reason": "SELECT decode(null, 6, 'Spark', NULL, map('a', 1), 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(null, 6, 'Spark', NULL, map('a', 1), 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#b0d288b8c109/ansi_on", @@ -3474,11 +3474,11 @@ }, { "id": "decode#b0eec5657c47/ansi_on", - "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#b0eec5657c47/ansi_off", - "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#b11be349e618/ansi_on", @@ -3866,11 +3866,11 @@ }, { "id": "decode#c1b654d45d8b/ansi_on", - "reason": "SELECT decode(null, 6, map('a', 1), NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(null, 6, map('a', 1), NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#c1b654d45d8b/ansi_off", - "reason": "SELECT decode(null, 6, map('a', 1), NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(null, 6, map('a', 1), NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#c253d61039cd/ansi_on", @@ -3944,14 +3944,6 @@ "id": "decode#c598c289e4ee/ansi_off", "reason": "SELECT decode(6, array(1, 2), 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "decode#c5d0ad6e7dc9/ansi_on", - "reason": "SELECT decode(map('a', 1), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "decode#c5d0ad6e7dc9/ansi_off", - "reason": "SELECT decode(map('a', 1), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "decode#c621cb6bfec6/ansi_on", "reason": "SELECT decode(2, 1, 'Southlake', 2, CAST(1.5 AS DECIMAL(10,2)), 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments" @@ -4274,11 +4266,11 @@ }, { "id": "decode#d326d0a5829e/ansi_on", - "reason": "SELECT decode(map('a', 1), 6, 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(map('a', 1), 6, 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#d326d0a5829e/ansi_off", - "reason": "SELECT decode(map('a', 1), 6, 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(map('a', 1), 6, 'Spark', NULL, 'SQL', 4, 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#d37b5333c9b6/ansi_on", @@ -4378,19 +4370,19 @@ }, { "id": "decode#d82c077e487a/ansi_on", - "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, map('a', 1), 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, map('a', 1), 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#d82c077e487a/ansi_off", - "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, map('a', 1), 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, map('a', 1), 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#d8fb98d952b5/ansi_on", - "reason": "SELECT decode(map('a', 1), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(map('a', 1), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#d8fb98d952b5/ansi_off", - "reason": "SELECT decode(map('a', 1), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(map('a', 1), 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#d8fbee5afce7/ansi_on", @@ -4482,11 +4474,11 @@ }, { "id": "decode#dc477346e985/ansi_on", - "reason": "SELECT decode(6, 1, 'Southlake', map('a', 1), 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', map('a', 1), 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#dc477346e985/ansi_off", - "reason": "SELECT decode(6, 1, 'Southlake', map('a', 1), 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', map('a', 1), 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#dcfb79179cdd/ansi_on", @@ -4810,11 +4802,11 @@ }, { "id": "decode#ee1305371937/ansi_on", - "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, map('a', 1), 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, map('a', 1), 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#ee1305371937/ansi_off", - "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, map('a', 1), 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + "reason": "SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, map('a', 1), 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "decode#ee426f7ea74e/ansi_on", @@ -5096,14 +5088,6 @@ "id": "decode#f8a51b8e436e/ansi_off", "reason": "SELECT decode(2, 1, CAST(1.5 AS DECIMAL(10,2)), 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments" }, - { - "id": "decode#f9a0e33e9376/ansi_on", - "reason": "SELECT decode(encode('abc', 'utf-8'), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "decode#f9a0e33e9376/ansi_off", - "reason": "SELECT decode(encode('abc', 'utf-8'), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "decode#fa3e52cdc232/ansi_on", "reason": "SELECT decode(6, 1, 'Southlake', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', 'San Francisco', 3, 'New Jersey', 4, 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" @@ -5122,11 +5106,11 @@ }, { "id": "decode#fb3e5c2fc925/ansi_on", - "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', map('a', 1), 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" + "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', map('a', 1), 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" }, { "id": "decode#fb3e5c2fc925/ansi_off", - "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', map('a', 1), 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" + "reason": "SELECT decode(null, 6, 'Spark', NULL, 'SQL', map('a', 1), 'rocks') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.INVALID_ORDERING_TYPE" }, { "id": "decode#fb43b4c07979/ansi_on", @@ -5178,11 +5162,11 @@ }, { "id": "decode#fd83e68ae0ee/ansi_on", - "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', map('a', 1), 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', map('a', 1), 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#fd83e68ae0ee/ansi_off", - "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', map('a', 1), 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" + "reason": "SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', map('a', 1), 'Seattle') | KRISHIV_UNSUPPORTED_FEATURE: decode with search and result arguments where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, { "id": "decode#fd84aef19beb/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/degrees.json b/tests/fixtures/analysis/registry-matrix/degrees.json index af8f5bd9f..78c84b62c 100644 --- a/tests/fixtures/analysis/registry-matrix/degrees.json +++ b/tests/fixtures/analysis/registry-matrix/degrees.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "degrees#9a381aac8d04/ansi_on", - "reason": "SELECT degrees(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, { "id": "degrees#baea01745120/ansi_on", "reason": "SELECT degrees(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/elt.json b/tests/fixtures/analysis/registry-matrix/elt.json index 503312f55..e14400f54 100644 --- a/tests/fixtures/analysis/registry-matrix/elt.json +++ b/tests/fixtures/analysis/registry-matrix/elt.json @@ -40,22 +40,6 @@ "id": "elt#a5032d6ca00a/ansi_off", "reason": "SELECT elt(1, INTERVAL '1 02:03:04' DAY TO SECOND, 'java') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "elt#b4eaf5559af2/ansi_on", - "reason": "SELECT elt(map('a', 1), 'scala', 'java') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "elt#b4eaf5559af2/ansi_off", - "reason": "SELECT elt(map('a', 1), 'scala', 'java') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "elt#c38603756666/ansi_on", - "reason": "SELECT elt(1, 'scala', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "elt#c38603756666/ansi_off", - "reason": "SELECT elt(1, 'scala', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "elt#ca50194da446/ansi_on", "reason": "SELECT elt(1, 'scala', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -63,14 +47,6 @@ { "id": "elt#ca50194da446/ansi_off", "reason": "SELECT elt(1, 'scala', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "elt#f20a314e8e06/ansi_on", - "reason": "SELECT elt(1, map('a', 1), 'java') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "elt#f20a314e8e06/ansi_off", - "reason": "SELECT elt(1, map('a', 1), 'java') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/encode.json b/tests/fixtures/analysis/registry-matrix/encode.json index e8c92dcf6..ff5e88633 100644 --- a/tests/fixtures/analysis/registry-matrix/encode.json +++ b/tests/fixtures/analysis/registry-matrix/encode.json @@ -8,14 +8,6 @@ "id": "encode#2a6551af8fb0/ansi_off", "reason": "SELECT encode(INTERVAL '1-2' YEAR TO MONTH, 'utf-8') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "encode#60a23e7ac424/ansi_on", - "reason": "SELECT encode('abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "encode#60a23e7ac424/ansi_off", - "reason": "SELECT encode('abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "encode#74c48c4e948c/ansi_on", "reason": "SELECT encode(INTERVAL '1 02:03:04' DAY TO SECOND, 'utf-8') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -39,14 +31,6 @@ { "id": "encode#ed99015663e0/ansi_off", "reason": "SELECT encode('abc', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "encode#f8cddc0cc0fd/ansi_on", - "reason": "SELECT encode(map('a', 1), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "encode#f8cddc0cc0fd/ansi_off", - "reason": "SELECT encode(map('a', 1), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/endswith.json b/tests/fixtures/analysis/registry-matrix/endswith.json index 8e810f8f4..fa8e362e2 100644 --- a/tests/fixtures/analysis/registry-matrix/endswith.json +++ b/tests/fixtures/analysis/registry-matrix/endswith.json @@ -8,22 +8,6 @@ "id": "endswith#3b9e39c48ee6/ansi_off", "reason": "SELECT endswith('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "endswith#3d0006240ac7/ansi_on", - "reason": "SELECT endswith('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "endswith#3d0006240ac7/ansi_off", - "reason": "SELECT endswith('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "endswith#7e3b0530126c/ansi_on", - "reason": "SELECT endswith(map('a', 1), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "endswith#7e3b0530126c/ansi_off", - "reason": "SELECT endswith(map('a', 1), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "endswith#7fc3b35cb0fa/ansi_on", "reason": "SELECT endswith(INTERVAL '1-2' YEAR TO MONTH, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/equal_null.json b/tests/fixtures/analysis/registry-matrix/equal_null.json index 9d6d42319..66053c094 100644 --- a/tests/fixtures/analysis/registry-matrix/equal_null.json +++ b/tests/fixtures/analysis/registry-matrix/equal_null.json @@ -36,14 +36,6 @@ "id": "equal_null#77395af26a6c/ansi_off", "reason": "SELECT equal_null(1, CAST(X'C328FF' AS STRING)) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "id": "equal_null#9426b8bc9b87/ansi_on", - "reason": "SELECT equal_null(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "equal_null#9426b8bc9b87/ansi_off", - "reason": "SELECT equal_null(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "equal_null#95f45a171b1c/ansi_off", "reason": "SELECT equal_null('1', 3) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" @@ -68,14 +60,6 @@ "id": "equal_null#b1fc9a5c815a/ansi_off", "reason": "SELECT equal_null(1, CAST(NULL AS string)) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "id": "equal_null#b43d593f7fd6/ansi_on", - "reason": "SELECT equal_null(3, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "equal_null#b43d593f7fd6/ansi_off", - "reason": "SELECT equal_null(3, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "equal_null#cff9dbd80a51/ansi_on", "reason": "SELECT equal_null(3, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/exp.json b/tests/fixtures/analysis/registry-matrix/exp.json index 497b14027..89175389a 100644 --- a/tests/fixtures/analysis/registry-matrix/exp.json +++ b/tests/fixtures/analysis/registry-matrix/exp.json @@ -15,14 +15,6 @@ { "id": "exp#c0495deda736/ansi_off", "reason": "SELECT exp(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "exp#f67051cd986a/ansi_on", - "reason": "SELECT exp(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/expm1.json b/tests/fixtures/analysis/registry-matrix/expm1.json index 43359a945..d51ca724e 100644 --- a/tests/fixtures/analysis/registry-matrix/expm1.json +++ b/tests/fixtures/analysis/registry-matrix/expm1.json @@ -1,13 +1,5 @@ { "entries": [ - { - "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#34c7be4db61b/ansi_off", - "reason": "SELECT expm1(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "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" diff --git a/tests/fixtures/analysis/registry-matrix/filter.json b/tests/fixtures/analysis/registry-matrix/filter.json index 79c47119e..1947bd54e 100644 --- a/tests/fixtures/analysis/registry-matrix/filter.json +++ b/tests/fixtures/analysis/registry-matrix/filter.json @@ -16,14 +16,6 @@ "id": "filter#87053e478033/ansi_off", "reason": "SELECT filter(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "filter#b772a52335ae/ansi_on", - "reason": "SELECT filter(map('a', 1), x -> x % 2 == 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "filter#b772a52335ae/ansi_off", - "reason": "SELECT filter(map('a', 1), x -> x % 2 == 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "filter#cc869a817020/ansi_on", "reason": "SELECT filter(array(0, 2, 3), (x, i) -> x > i) | INVALID_LAMBDA_FUNCTION_CALL.NUM_ARGS_MISMATCH" diff --git a/tests/fixtures/analysis/registry-matrix/find_in_set.json b/tests/fixtures/analysis/registry-matrix/find_in_set.json index 332f1c65f..40aa45e86 100644 --- a/tests/fixtures/analysis/registry-matrix/find_in_set.json +++ b/tests/fixtures/analysis/registry-matrix/find_in_set.json @@ -8,14 +8,6 @@ "id": "find_in_set#09e908e71f87/ansi_off", "reason": "SELECT find_in_set(INTERVAL '1-2' YEAR TO MONTH,'abc,b,ab,c,def') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "find_in_set#113a14f95db3/ansi_on", - "reason": "SELECT find_in_set(map('a', 1),'abc,b,ab,c,def') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "find_in_set#113a14f95db3/ansi_off", - "reason": "SELECT find_in_set(map('a', 1),'abc,b,ab,c,def') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "find_in_set#13c7df199694/ansi_on", "reason": "SELECT find_in_set('ab',INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -24,14 +16,6 @@ "id": "find_in_set#13c7df199694/ansi_off", "reason": "SELECT find_in_set('ab',INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "find_in_set#6fa5b2df63d8/ansi_on", - "reason": "SELECT find_in_set('ab',map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "find_in_set#6fa5b2df63d8/ansi_off", - "reason": "SELECT find_in_set('ab',map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "find_in_set#73fb1df4d3b1/ansi_on", "reason": "SELECT find_in_set(INTERVAL '1 02:03:04' DAY TO SECOND,'abc,b,ab,c,def') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/first.json b/tests/fixtures/analysis/registry-matrix/first.json index 9f83e8128..8fea90b2d 100644 --- a/tests/fixtures/analysis/registry-matrix/first.json +++ b/tests/fixtures/analysis/registry-matrix/first.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "first#020dbe3f574a/ansi_on", - "reason": "SELECT first(col, map('a', 1)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "first#020dbe3f574a/ansi_off", - "reason": "SELECT first(col, map('a', 1)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" - }, { "id": "first#2c09bffba1c5/ansi_on", "reason": "SELECT first(col, INTERVAL '1-2' YEAR TO MONTH) FROM VALUES (NULL), (5), (20) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210" diff --git a/tests/fixtures/analysis/registry-matrix/first_value.json b/tests/fixtures/analysis/registry-matrix/first_value.json index 1219c968b..69983c7fc 100644 --- a/tests/fixtures/analysis/registry-matrix/first_value.json +++ b/tests/fixtures/analysis/registry-matrix/first_value.json @@ -15,14 +15,6 @@ { "id": "first_value#6a3c77cae004/ansi_off", "reason": "SELECT first_value(col, INTERVAL '1-2' YEAR TO MONTH) FROM VALUES (NULL), (5), (20) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "first_value#941eb00c2922/ansi_on", - "reason": "SELECT first_value(col, map('a', 1)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "first_value#941eb00c2922/ansi_off", - "reason": "SELECT first_value(col, map('a', 1)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/floor.json b/tests/fixtures/analysis/registry-matrix/floor.json index 6332f3d16..adc6daa46 100644 --- a/tests/fixtures/analysis/registry-matrix/floor.json +++ b/tests/fixtures/analysis/registry-matrix/floor.json @@ -1,13 +1,5 @@ { "entries": [ - { - "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#0c6d71158a9a/ansi_off", - "reason": "SELECT floor(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "floor#341fd846f969/ansi_on", "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" @@ -32,14 +24,6 @@ "id": "floor#48b0b9450007/ansi_off", "reason": "SELECT floor(3.1411, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has NON_FOLDABLE_ARGUMENT" }, - { - "id": "floor#4a2f3954364e/ansi_on", - "reason": "SELECT floor(3.1411, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has NON_FOLDABLE_ARGUMENT" - }, - { - "id": "floor#4a2f3954364e/ansi_off", - "reason": "SELECT floor(3.1411, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has NON_FOLDABLE_ARGUMENT" - }, { "id": "floor#716ba7127f26/ansi_on", "reason": "SELECT floor(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -63,14 +47,6 @@ { "id": "floor#a8fb09ca0432/ansi_off", "reason": "SELECT floor(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "floor#f7b36fd3e154/ansi_on", - "reason": "SELECT floor(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "floor#f7b36fd3e154/ansi_off", - "reason": "SELECT floor(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/forall.json b/tests/fixtures/analysis/registry-matrix/forall.json index 26b783b40..282f572c0 100644 --- a/tests/fixtures/analysis/registry-matrix/forall.json +++ b/tests/fixtures/analysis/registry-matrix/forall.json @@ -8,14 +8,6 @@ "id": "forall#0c7952ae1a01/ansi_off", "reason": "SELECT forall(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "forall#7781d8d40b2b/ansi_on", - "reason": "SELECT forall(map('a', 1), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "forall#7781d8d40b2b/ansi_off", - "reason": "SELECT forall(map('a', 1), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "forall#a88594001a66/ansi_on", "reason": "SELECT forall(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/format_number.json b/tests/fixtures/analysis/registry-matrix/format_number.json index af01653b9..9a1954432 100644 --- a/tests/fixtures/analysis/registry-matrix/format_number.json +++ b/tests/fixtures/analysis/registry-matrix/format_number.json @@ -8,14 +8,6 @@ "id": "format_number#283272e56f35/ansi_off", "reason": "SELECT format_number(INTERVAL '1-2' YEAR TO MONTH, 4) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "format_number#2b4b8c75c472/ansi_on", - "reason": "SELECT format_number(12332.123456, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "format_number#2b4b8c75c472/ansi_off", - "reason": "SELECT format_number(12332.123456, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "format_number#76613646826f/ansi_on", "reason": "SELECT format_number(12332.123456, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -39,14 +31,6 @@ { "id": "format_number#f2eb3f7a47db/ansi_off", "reason": "SELECT format_number(INTERVAL '1 02:03:04' DAY TO SECOND, 4) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "format_number#fe89b51ecaa9/ansi_on", - "reason": "SELECT format_number(map('a', 1), 4) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "format_number#fe89b51ecaa9/ansi_off", - "reason": "SELECT format_number(map('a', 1), 4) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json b/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json index c7adbc4d4..36a8e1ee2 100644 --- a/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json +++ b/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "from_utc_timestamp#10d4c109c64a/ansi_on", - "reason": "SELECT from_utc_timestamp(map('a', 1), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "from_utc_timestamp#10d4c109c64a/ansi_off", - "reason": "SELECT from_utc_timestamp(map('a', 1), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "from_utc_timestamp#1f83bb6cdcab/ansi_on", "reason": "SELECT from_utc_timestamp(INTERVAL '1 02:03:04' DAY TO SECOND, 'Asia/Seoul') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "from_utc_timestamp#70953829339b/ansi_off", "reason": "SELECT from_utc_timestamp('2016-08-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "from_utc_timestamp#83b5c806c510/ansi_on", - "reason": "SELECT from_utc_timestamp('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "from_utc_timestamp#83b5c806c510/ansi_off", - "reason": "SELECT from_utc_timestamp('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "from_utc_timestamp#c986a44036f4/ansi_on", "reason": "SELECT from_utc_timestamp('2016-08-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/getbit.json b/tests/fixtures/analysis/registry-matrix/getbit.json index 8df20ef0d..2ce75fbde 100644 --- a/tests/fixtures/analysis/registry-matrix/getbit.json +++ b/tests/fixtures/analysis/registry-matrix/getbit.json @@ -8,14 +8,6 @@ "id": "getbit#1d931eb55d80/ansi_off", "reason": "SELECT getbit(INTERVAL '1-2' YEAR TO MONTH, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "getbit#62e5bcef8380/ansi_on", - "reason": "SELECT getbit(11, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "getbit#62e5bcef8380/ansi_off", - "reason": "SELECT getbit(11, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "getbit#7579ff069735/ansi_on", "reason": "SELECT getbit(INTERVAL '1 02:03:04' DAY TO SECOND, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -24,14 +16,6 @@ "id": "getbit#7579ff069735/ansi_off", "reason": "SELECT getbit(INTERVAL '1 02:03:04' DAY TO SECOND, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "getbit#915c2a9d1452/ansi_on", - "reason": "SELECT getbit(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "getbit#915c2a9d1452/ansi_off", - "reason": "SELECT getbit(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "getbit#9a65369e9227/ansi_on", "reason": "SELECT getbit(11, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/greatest.json b/tests/fixtures/analysis/registry-matrix/greatest.json index 03c69d430..cdcb8c237 100644 --- a/tests/fixtures/analysis/registry-matrix/greatest.json +++ b/tests/fixtures/analysis/registry-matrix/greatest.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "greatest#057f3a80d763/ansi_on", - "reason": "SELECT greatest(10, 9, 2, 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "greatest#057f3a80d763/ansi_off", - "reason": "SELECT greatest(10, 9, 2, 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "greatest#096852702824/ansi_on", "reason": "SELECT greatest(INTERVAL '1 02:03:04' DAY TO SECOND, 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -56,14 +48,6 @@ "id": "greatest#69f9244398a6/ansi_off", "reason": "SELECT greatest(10, 9, 2, 4, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "greatest#824668970bd6/ansi_on", - "reason": "SELECT greatest(map('a', 1), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "greatest#824668970bd6/ansi_off", - "reason": "SELECT greatest(map('a', 1), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "greatest#98f8bb73a148/ansi_on", "reason": "SELECT greatest(10, INTERVAL '1 02:03:04' DAY TO SECOND, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -88,22 +72,6 @@ "id": "greatest#ac8fdf5710d4/ansi_off", "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#b2adb244d3ee/ansi_on", - "reason": "SELECT greatest(10, 9, 2, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "greatest#b2adb244d3ee/ansi_off", - "reason": "SELECT greatest(10, 9, 2, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "greatest#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#c02bd5367c35/ansi_off", - "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#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" @@ -111,14 +79,6 @@ { "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" - }, - { - "id": "greatest#e07bc566123a/ansi_on", - "reason": "SELECT greatest(10, map('a', 1), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/hash.json b/tests/fixtures/analysis/registry-matrix/hash.json index 37b3a1127..f6039f6d6 100644 --- a/tests/fixtures/analysis/registry-matrix/hash.json +++ b/tests/fixtures/analysis/registry-matrix/hash.json @@ -10,19 +10,19 @@ }, { "id": "hash#51a176d3611e/ansi_on", - "reason": "SELECT hash('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT hash('Spark', map('a', 1), 2) | resolves to int where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "hash#51a176d3611e/ansi_off", - "reason": "SELECT hash('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT hash('Spark', map('a', 1), 2) | resolves to int where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "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" + "reason": "SELECT hash(map('a', 1), array(123), 2) | resolves to int where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "hash#68ccd0f7afcd/ansi_off", - "reason": "SELECT hash(map('a', 1), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT hash(map('a', 1), array(123), 2) | resolves to int where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "hash#7d1796847464/ansi_on", @@ -66,11 +66,11 @@ }, { "id": "hash#f0c7f0566e00/ansi_on", - "reason": "SELECT hash('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT hash('Spark', array(123), map('a', 1)) | resolves to int where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "hash#f0c7f0566e00/ansi_off", - "reason": "SELECT hash('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT hash('Spark', array(123), map('a', 1)) | resolves to int where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/hex.json b/tests/fixtures/analysis/registry-matrix/hex.json index 4e228c1eb..59ac2c056 100644 --- a/tests/fixtures/analysis/registry-matrix/hex.json +++ b/tests/fixtures/analysis/registry-matrix/hex.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "hex#210145b407c5/ansi_on", - "reason": "SELECT hex(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "hex#210145b407c5/ansi_off", - "reason": "SELECT hex(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "hex#61f6d2c71dd9/ansi_on", "reason": "SELECT hex(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/hour.json b/tests/fixtures/analysis/registry-matrix/hour.json index 8b0b33083..6bf8c6c9d 100644 --- a/tests/fixtures/analysis/registry-matrix/hour.json +++ b/tests/fixtures/analysis/registry-matrix/hour.json @@ -16,14 +16,6 @@ "id": "hour#764b1ec0e160/ansi_off", "reason": "SELECT hour(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "hour#77ebb4580894/ansi_on", - "reason": "SELECT hour(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "hour#77ebb4580894/ansi_off", - "reason": "SELECT hour(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "hour#87a038cb355d/ansi_on", "reason": "SELECT hour(TIME'13:59:59.999999') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIME literals where Spark has UNSUPPORTED_TIME_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/hypot.json b/tests/fixtures/analysis/registry-matrix/hypot.json index fd6d0b900..68a14ba31 100644 --- a/tests/fixtures/analysis/registry-matrix/hypot.json +++ b/tests/fixtures/analysis/registry-matrix/hypot.json @@ -16,14 +16,6 @@ "id": "hypot#176ba9f19b92/ansi_off", "reason": "SELECT hypot(INTERVAL '1 02:03:04' DAY TO SECOND, 4) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "hypot#439f817c8846/ansi_on", - "reason": "SELECT hypot(3, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "hypot#439f817c8846/ansi_off", - "reason": "SELECT hypot(3, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "hypot#5688a3994502/ansi_on", "reason": "SELECT hypot(3, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "hypot#5688a3994502/ansi_off", "reason": "SELECT hypot(3, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "hypot#5c6c6b1a9581/ansi_on", - "reason": "SELECT hypot(map('a', 1), 4) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "hypot#5c6c6b1a9581/ansi_off", - "reason": "SELECT hypot(map('a', 1), 4) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "hypot#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" diff --git a/tests/fixtures/analysis/registry-matrix/if.json b/tests/fixtures/analysis/registry-matrix/if.json index b2620f1a2..8cef58cd5 100644 --- a/tests/fixtures/analysis/registry-matrix/if.json +++ b/tests/fixtures/analysis/registry-matrix/if.json @@ -1,21 +1,5 @@ { "entries": [ - { - "id": "if#164ab1aafa5c/ansi_on", - "reason": "SELECT if(1 < 2, map('a', 1), 'b') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "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" - }, - { - "id": "if#25da6a72b40e/ansi_on", - "reason": "SELECT if(1 < 2, 'a', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "if#25da6a72b40e/ansi_off", - "reason": "SELECT if(1 < 2, 'a', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "if#31f5f0b7479b/ansi_on", "reason": "SELECT if(INTERVAL '1-2' YEAR TO MONTH, 'a', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -63,14 +47,6 @@ { "id": "if#b6e3ea7b11fd/ansi_off", "reason": "SELECT if(1 < 2, INTERVAL '1 02:03:04' DAY TO SECOND, 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "if#ec0d1d6bf87a/ansi_on", - "reason": "SELECT if(map('a', 1), 'a', 'b') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/ifnull.json b/tests/fixtures/analysis/registry-matrix/ifnull.json index 58d148c20..7ed6b2b93 100644 --- a/tests/fixtures/analysis/registry-matrix/ifnull.json +++ b/tests/fixtures/analysis/registry-matrix/ifnull.json @@ -16,14 +16,6 @@ "id": "ifnull#3fead29b1417/ansi_off", "reason": "SELECT ifnull(INTERVAL '1 02:03:04' DAY TO SECOND, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "ifnull#5c3f20483580/ansi_on", - "reason": "SELECT ifnull(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#5c3f20483580/ansi_off", - "reason": "SELECT ifnull(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "ifnull#ca112c5b4ed3/ansi_on", "reason": "SELECT ifnull(NULL, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -32,14 +24,6 @@ "id": "ifnull#ca112c5b4ed3/ansi_off", "reason": "SELECT ifnull(NULL, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "ifnull#d7660483e606/ansi_on", - "reason": "SELECT ifnull(NULL, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "ifnull#d7660483e606/ansi_off", - "reason": "SELECT ifnull(NULL, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, { "id": "ifnull#e500a975bbe1/ansi_on", "reason": "SELECT ifnull(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/initcap.json b/tests/fixtures/analysis/registry-matrix/initcap.json index 8bc0555f4..43a66a232 100644 --- a/tests/fixtures/analysis/registry-matrix/initcap.json +++ b/tests/fixtures/analysis/registry-matrix/initcap.json @@ -8,14 +8,6 @@ "id": "initcap#44cff88f8f59/ansi_off", "reason": "SELECT initcap(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "initcap#74029dd0c2d3/ansi_on", - "reason": "SELECT initcap(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "initcap#74029dd0c2d3/ansi_off", - "reason": "SELECT initcap(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "initcap#be1f008f9285/ansi_on", "reason": "SELECT initcap(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/instr.json b/tests/fixtures/analysis/registry-matrix/instr.json index d58988e78..be5800a7c 100644 --- a/tests/fixtures/analysis/registry-matrix/instr.json +++ b/tests/fixtures/analysis/registry-matrix/instr.json @@ -24,14 +24,6 @@ "id": "instr#5ed8b1a7d582/ansi_off", "reason": "SELECT instr('SparkSQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "instr#ca28524036fb/ansi_on", - "reason": "SELECT instr(map('a', 1), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "instr#ca28524036fb/ansi_off", - "reason": "SELECT instr(map('a', 1), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "instr#ec7195993f97/ansi_on", "reason": "SELECT instr(INTERVAL '1-2' YEAR TO MONTH, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -39,14 +31,6 @@ { "id": "instr#ec7195993f97/ansi_off", "reason": "SELECT instr(INTERVAL '1-2' YEAR TO MONTH, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "instr#f4554b8c4cf6/ansi_on", - "reason": "SELECT instr('SparkSQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "instr#f4554b8c4cf6/ansi_off", - "reason": "SELECT instr('SparkSQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/is_valid_utf8.json b/tests/fixtures/analysis/registry-matrix/is_valid_utf8.json index 3e344449a..286c4927c 100644 --- a/tests/fixtures/analysis/registry-matrix/is_valid_utf8.json +++ b/tests/fixtures/analysis/registry-matrix/is_valid_utf8.json @@ -8,14 +8,6 @@ "id": "is_valid_utf8#1818de4df6e2/ansi_off", "reason": "SELECT is_valid_utf8(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "is_valid_utf8#1fde386c23fb/ansi_on", - "reason": "SELECT is_valid_utf8(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "is_valid_utf8#1fde386c23fb/ansi_off", - "reason": "SELECT is_valid_utf8(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "is_valid_utf8#471e1888f6c8/ansi_on", "reason": "SELECT is_valid_utf8(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/isnan.json b/tests/fixtures/analysis/registry-matrix/isnan.json index d1a19d895..e9e24a8c4 100644 --- a/tests/fixtures/analysis/registry-matrix/isnan.json +++ b/tests/fixtures/analysis/registry-matrix/isnan.json @@ -8,14 +8,6 @@ "id": "isnan#25d2f4c654b1/ansi_off", "reason": "SELECT isnan(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "isnan#29e561a2c026/ansi_on", - "reason": "SELECT isnan(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "isnan#29e561a2c026/ansi_off", - "reason": "SELECT isnan(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "isnan#f996f90ad990/ansi_on", "reason": "SELECT isnan(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/isnotnull.json b/tests/fixtures/analysis/registry-matrix/isnotnull.json index a5589fc29..20ad6801c 100644 --- a/tests/fixtures/analysis/registry-matrix/isnotnull.json +++ b/tests/fixtures/analysis/registry-matrix/isnotnull.json @@ -8,14 +8,6 @@ "id": "isnotnull#09632d6177fe/ansi_off", "reason": "SELECT isnotnull(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "isnotnull#14b5ca08d93a/ansi_on", - "reason": "SELECT isnotnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "isnotnull#14b5ca08d93a/ansi_off", - "reason": "SELECT isnotnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, { "id": "isnotnull#72997046ecf4/ansi_on", "reason": "SELECT isnotnull(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/isnull.json b/tests/fixtures/analysis/registry-matrix/isnull.json index 4b10cc1c6..d6e328902 100644 --- a/tests/fixtures/analysis/registry-matrix/isnull.json +++ b/tests/fixtures/analysis/registry-matrix/isnull.json @@ -8,14 +8,6 @@ "id": "isnull#1f87a03f0d8b/ansi_off", "reason": "SELECT isnull(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "isnull#2013e66b962e/ansi_on", - "reason": "SELECT isnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "isnull#2013e66b962e/ansi_off", - "reason": "SELECT isnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, { "id": "isnull#56c254dd036b/ansi_on", "reason": "SELECT isnull(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/last.json b/tests/fixtures/analysis/registry-matrix/last.json index 7c0ae4b4c..bc5ca9160 100644 --- a/tests/fixtures/analysis/registry-matrix/last.json +++ b/tests/fixtures/analysis/registry-matrix/last.json @@ -15,14 +15,6 @@ { "id": "last#8043a9ea738f/ansi_off", "reason": "SELECT last(col, INTERVAL '1 02:03:04' DAY TO SECOND) FROM VALUES (10), (5), (NULL) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "last#8d76e63681f0/ansi_on", - "reason": "SELECT last(col, map('a', 1)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "last#8d76e63681f0/ansi_off", - "reason": "SELECT last(col, map('a', 1)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/last_day.json b/tests/fixtures/analysis/registry-matrix/last_day.json index 24aafe842..2c8fdd22d 100644 --- a/tests/fixtures/analysis/registry-matrix/last_day.json +++ b/tests/fixtures/analysis/registry-matrix/last_day.json @@ -8,14 +8,6 @@ "id": "last_day#512b0d5c0186/ansi_off", "reason": "SELECT last_day(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "last_day#6952126118a9/ansi_on", - "reason": "SELECT last_day(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "last_day#6952126118a9/ansi_off", - "reason": "SELECT last_day(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "last_day#ccb5b77f56ff/ansi_on", "reason": "SELECT last_day(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/last_value.json b/tests/fixtures/analysis/registry-matrix/last_value.json index 2a1cbc388..2d3bacbc3 100644 --- a/tests/fixtures/analysis/registry-matrix/last_value.json +++ b/tests/fixtures/analysis/registry-matrix/last_value.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "last_value#59116f565aa7/ansi_on", - "reason": "SELECT last_value(col, map('a', 1)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "last_value#59116f565aa7/ansi_off", - "reason": "SELECT last_value(col, map('a', 1)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" - }, { "id": "last_value#622de0ac1241/ansi_on", "reason": "SELECT last_value(col, INTERVAL '1 02:03:04' DAY TO SECOND) FROM VALUES (10), (5), (NULL) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210" diff --git a/tests/fixtures/analysis/registry-matrix/lcase.json b/tests/fixtures/analysis/registry-matrix/lcase.json index f3642d738..30c6942dc 100644 --- a/tests/fixtures/analysis/registry-matrix/lcase.json +++ b/tests/fixtures/analysis/registry-matrix/lcase.json @@ -8,14 +8,6 @@ "id": "lcase#5f8ebfb97b33/ansi_off", "reason": "SELECT lcase(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "lcase#a43c0260bd5e/ansi_on", - "reason": "SELECT lcase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lcase#a43c0260bd5e/ansi_off", - "reason": "SELECT lcase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "lcase#b5e40db8ea93/ansi_on", "reason": "SELECT lcase(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/least.json b/tests/fixtures/analysis/registry-matrix/least.json index 0ee928d2b..42d1b4532 100644 --- a/tests/fixtures/analysis/registry-matrix/least.json +++ b/tests/fixtures/analysis/registry-matrix/least.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "least#266447befe5d/ansi_on", - "reason": "SELECT least(10, 9, 2, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, { "id": "least#2b19e87dc568/ansi_on", "reason": "SELECT least(INTERVAL '1-2' YEAR TO MONTH, 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -32,14 +24,6 @@ "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" }, - { - "id": "least#5d99bc1c942d/ansi_on", - "reason": "SELECT least(map('a', 1), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "least#5d99bc1c942d/ansi_off", - "reason": "SELECT least(map('a', 1), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "least#64ec2bf5cefb/ansi_on", "reason": "SELECT least(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" @@ -48,14 +32,6 @@ "id": "least#64ec2bf5cefb/ansi_off", "reason": "SELECT least(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": "least#697173b99bea/ansi_on", - "reason": "SELECT least(10, 9, 2, 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "least#697173b99bea/ansi_off", - "reason": "SELECT least(10, 9, 2, 4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "least#71bcc5afbbb5/ansi_on", "reason": "SELECT least(INTERVAL '1 02:03:04' DAY TO SECOND, 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -96,22 +72,6 @@ "id": "least#c9491beacab8/ansi_off", "reason": "SELECT least(10, INTERVAL '1 02:03:04' DAY TO SECOND, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "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#d3ab4c4be0fe/ansi_off", - "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#eb6e2c2c1be6/ansi_on", - "reason": "SELECT least(10, map('a', 1), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "least#eb6e2c2c1be6/ansi_off", - "reason": "SELECT least(10, map('a', 1), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "least#f966d17db1a4/ansi_on", "reason": "SELECT least(10, 9, 2, 4, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/left.json b/tests/fixtures/analysis/registry-matrix/left.json index f39bfbb19..2c59625d5 100644 --- a/tests/fixtures/analysis/registry-matrix/left.json +++ b/tests/fixtures/analysis/registry-matrix/left.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "left#2507b987e753/ansi_on", - "reason": "SELECT left(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "left#2507b987e753/ansi_off", - "reason": "SELECT left(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "left#4d174cea6a96/ansi_on", "reason": "SELECT left(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -24,14 +16,6 @@ "id": "left#93a948cf2df5/ansi_off", "reason": "SELECT left('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "left#97e5f58c23cc/ansi_on", - "reason": "SELECT left('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "left#97e5f58c23cc/ansi_off", - "reason": "SELECT left('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "left#b474cc252a1e/ansi_on", "reason": "SELECT left(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/len.json b/tests/fixtures/analysis/registry-matrix/len.json index a8d9f5803..0755fe86c 100644 --- a/tests/fixtures/analysis/registry-matrix/len.json +++ b/tests/fixtures/analysis/registry-matrix/len.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "len#0dc71cd27cae/ansi_on", - "reason": "SELECT len(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "len#0dc71cd27cae/ansi_off", - "reason": "SELECT len(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "len#89747546a701/ansi_on", "reason": "SELECT len(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/length.json b/tests/fixtures/analysis/registry-matrix/length.json index 4df3bd90c..52ccab870 100644 --- a/tests/fixtures/analysis/registry-matrix/length.json +++ b/tests/fixtures/analysis/registry-matrix/length.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "length#3850ba7284e8/ansi_on", - "reason": "SELECT length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "length#3850ba7284e8/ansi_off", - "reason": "SELECT length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "length#c112063cc572/ansi_on", "reason": "SELECT length(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/levenshtein.json b/tests/fixtures/analysis/registry-matrix/levenshtein.json index b131f6f1f..0f69f934c 100644 --- a/tests/fixtures/analysis/registry-matrix/levenshtein.json +++ b/tests/fixtures/analysis/registry-matrix/levenshtein.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "levenshtein#1f75a6646bcf/ansi_on", - "reason": "SELECT levenshtein('kitten', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "levenshtein#1f75a6646bcf/ansi_off", - "reason": "SELECT levenshtein('kitten', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "levenshtein#2151df8b71f9/ansi_on", "reason": "SELECT levenshtein('kitten', 'sitting', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -24,14 +16,6 @@ "id": "levenshtein#2ab177355128/ansi_off", "reason": "SELECT levenshtein('kitten', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "levenshtein#3926e67ae481/ansi_on", - "reason": "SELECT levenshtein(map('a', 1), 'sitting') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "levenshtein#3926e67ae481/ansi_off", - "reason": "SELECT levenshtein(map('a', 1), 'sitting') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "levenshtein#45c5cc2454fe/ansi_on", "reason": "SELECT levenshtein('kitten', INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -40,14 +24,6 @@ "id": "levenshtein#45c5cc2454fe/ansi_off", "reason": "SELECT levenshtein('kitten', INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "levenshtein#53b471b728dc/ansi_on", - "reason": "SELECT levenshtein('kitten', 'sitting', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "levenshtein#53b471b728dc/ansi_off", - "reason": "SELECT levenshtein('kitten', 'sitting', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "levenshtein#8bc15785b8fe/ansi_on", "reason": "SELECT levenshtein(INTERVAL '1-2' YEAR TO MONTH, 'sitting') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -56,14 +32,6 @@ "id": "levenshtein#8bc15785b8fe/ansi_off", "reason": "SELECT levenshtein(INTERVAL '1-2' YEAR TO MONTH, 'sitting') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "levenshtein#8f66ac67ffcb/ansi_on", - "reason": "SELECT levenshtein('kitten', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "levenshtein#8f66ac67ffcb/ansi_off", - "reason": "SELECT levenshtein('kitten', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "levenshtein#9c6d182ed649/ansi_on", "reason": "SELECT levenshtein(INTERVAL '1-2' YEAR TO MONTH, 'sitting', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -96,14 +64,6 @@ "id": "levenshtein#ab0b77246dee/ansi_off", "reason": "SELECT levenshtein('kitten', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "levenshtein#b19d7855506e/ansi_on", - "reason": "SELECT levenshtein(map('a', 1), 'sitting', 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "levenshtein#b19d7855506e/ansi_off", - "reason": "SELECT levenshtein(map('a', 1), 'sitting', 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "levenshtein#ca49decba07e/ansi_on", "reason": "SELECT levenshtein(INTERVAL '1 02:03:04' DAY TO SECOND, 'sitting') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/ln.json b/tests/fixtures/analysis/registry-matrix/ln.json index 691c981a6..1a4cdc709 100644 --- a/tests/fixtures/analysis/registry-matrix/ln.json +++ b/tests/fixtures/analysis/registry-matrix/ln.json @@ -15,14 +15,6 @@ { "id": "ln#e46d79f0541d/ansi_off", "reason": "SELECT ln(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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": "ln#e85171130f3f/ansi_off", - "reason": "SELECT ln(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/locate.json b/tests/fixtures/analysis/registry-matrix/locate.json index fea2eed8c..3d8f33d04 100644 --- a/tests/fixtures/analysis/registry-matrix/locate.json +++ b/tests/fixtures/analysis/registry-matrix/locate.json @@ -64,38 +64,6 @@ "id": "locate#9c369d1fb51b/ansi_off", "reason": "SELECT locate('bar', INTERVAL '1 02:03:04' DAY TO SECOND, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "locate#a7767364d0b8/ansi_on", - "reason": "SELECT locate(map('a', 1), 'foobarbar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "locate#a7767364d0b8/ansi_off", - "reason": "SELECT locate(map('a', 1), 'foobarbar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "locate#b74e2d74ab2f/ansi_on", - "reason": "SELECT locate('bar', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "locate#b74e2d74ab2f/ansi_off", - "reason": "SELECT locate('bar', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "locate#c3f4168b42eb/ansi_on", - "reason": "SELECT locate(map('a', 1), 'foobarbar', 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "locate#c3f4168b42eb/ansi_off", - "reason": "SELECT locate(map('a', 1), 'foobarbar', 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "locate#c7fe7c11d1a0/ansi_on", - "reason": "SELECT locate('bar', 'foobarbar', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "locate#c7fe7c11d1a0/ansi_off", - "reason": "SELECT locate('bar', 'foobarbar', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "locate#d7063806fdbe/ansi_on", "reason": "SELECT locate('bar', INTERVAL '1-2' YEAR TO MONTH, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -104,14 +72,6 @@ "id": "locate#d7063806fdbe/ansi_off", "reason": "SELECT locate('bar', INTERVAL '1-2' YEAR TO MONTH, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "locate#f4332c0ebfcb/ansi_on", - "reason": "SELECT locate('bar', map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "locate#f4332c0ebfcb/ansi_off", - "reason": "SELECT locate('bar', map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "locate#ffc3f838bcdf/ansi_on", "reason": "SELECT locate(INTERVAL '1 02:03:04' DAY TO SECOND, 'foobarbar') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/log.json b/tests/fixtures/analysis/registry-matrix/log.json index 7cd282f35..79dc1566c 100644 --- a/tests/fixtures/analysis/registry-matrix/log.json +++ b/tests/fixtures/analysis/registry-matrix/log.json @@ -1,13 +1,5 @@ { "entries": [ - { - "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#2849851ffff9/ansi_off", - "reason": "SELECT log(10, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "log#6e4cd2e20dbf/ansi_on", "reason": "SELECT log(10, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -16,14 +8,6 @@ "id": "log#6e4cd2e20dbf/ansi_off", "reason": "SELECT log(10, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "log#94eb25460542/ansi_on", - "reason": "SELECT log(map('a', 1), 100) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "log#94eb25460542/ansi_off", - "reason": "SELECT log(map('a', 1), 100) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "log#b29ab2f7e498/ansi_on", "reason": "SELECT log(INTERVAL '1 02:03:04' DAY TO SECOND, 100) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/log10.json b/tests/fixtures/analysis/registry-matrix/log10.json index d9e5e16ee..ff494d039 100644 --- a/tests/fixtures/analysis/registry-matrix/log10.json +++ b/tests/fixtures/analysis/registry-matrix/log10.json @@ -8,14 +8,6 @@ "id": "log10#3f6a0f6d439f/ansi_off", "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#a5850baae0e0/ansi_on", - "reason": "SELECT log10(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, { "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" diff --git a/tests/fixtures/analysis/registry-matrix/log1p.json b/tests/fixtures/analysis/registry-matrix/log1p.json index 819f82863..1eca06cdf 100644 --- a/tests/fixtures/analysis/registry-matrix/log1p.json +++ b/tests/fixtures/analysis/registry-matrix/log1p.json @@ -1,13 +1,5 @@ { "entries": [ - { - "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#10a3a0932d37/ansi_off", - "reason": "SELECT log1p(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "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" diff --git a/tests/fixtures/analysis/registry-matrix/log2.json b/tests/fixtures/analysis/registry-matrix/log2.json index 5ff2252b6..d71ffa4da 100644 --- a/tests/fixtures/analysis/registry-matrix/log2.json +++ b/tests/fixtures/analysis/registry-matrix/log2.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "log2#0784ad8106b9/ansi_on", - "reason": "SELECT log2(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "log2#0784ad8106b9/ansi_off", - "reason": "SELECT log2(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "log2#5b428c8fab2e/ansi_on", "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" diff --git a/tests/fixtures/analysis/registry-matrix/lower.json b/tests/fixtures/analysis/registry-matrix/lower.json index 87a610cc6..57a987fe3 100644 --- a/tests/fixtures/analysis/registry-matrix/lower.json +++ b/tests/fixtures/analysis/registry-matrix/lower.json @@ -8,14 +8,6 @@ "id": "lower#2130df7157cc/ansi_off", "reason": "SELECT lower(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "lower#3bb228f7d65c/ansi_on", - "reason": "SELECT lower(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lower#3bb228f7d65c/ansi_off", - "reason": "SELECT lower(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "lower#f2581497b448/ansi_on", "reason": "SELECT lower(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/lpad.json b/tests/fixtures/analysis/registry-matrix/lpad.json index 7cf0a5260..882a13408 100644 --- a/tests/fixtures/analysis/registry-matrix/lpad.json +++ b/tests/fixtures/analysis/registry-matrix/lpad.json @@ -24,30 +24,6 @@ "id": "lpad#410a80e8c9ac/ansi_off", "reason": "SELECT lpad('hi', INTERVAL '1 02:03:04' DAY TO SECOND, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "lpad#60bd64d2fdce/ansi_on", - "reason": "SELECT lpad('hi', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#60bd64d2fdce/ansi_off", - "reason": "SELECT lpad('hi', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#7a419bc53ab4/ansi_on", - "reason": "SELECT lpad(map('a', 1), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#7a419bc53ab4/ansi_off", - "reason": "SELECT lpad(map('a', 1), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#86f3021e158c/ansi_on", - "reason": "SELECT lpad(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#86f3021e158c/ansi_off", - "reason": "SELECT lpad(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "lpad#9a853a142660/ansi_on", "reason": "SELECT lpad('hi', INTERVAL '1-2' YEAR TO MONTH, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +40,6 @@ "id": "lpad#9af45a0bcbe7/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" }, - { - "id": "lpad#ac299a792a53/ansi_on", - "reason": "SELECT lpad('hi', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#ac299a792a53/ansi_off", - "reason": "SELECT lpad('hi', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "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" @@ -96,14 +64,6 @@ "id": "lpad#dbfd66f4ecec/ansi_off", "reason": "SELECT lpad(INTERVAL '1-2' YEAR TO MONTH, 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "lpad#f2b862964cf6/ansi_on", - "reason": "SELECT lpad('hi', map('a', 1), '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#f2b862964cf6/ansi_off", - "reason": "SELECT lpad('hi', map('a', 1), '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "lpad#f5930f28714a/ansi_on", "reason": "SELECT lpad(INTERVAL '1 02:03:04' DAY TO SECOND, 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/ltrim.json b/tests/fixtures/analysis/registry-matrix/ltrim.json index d10627540..0d9ec8cb6 100644 --- a/tests/fixtures/analysis/registry-matrix/ltrim.json +++ b/tests/fixtures/analysis/registry-matrix/ltrim.json @@ -15,14 +15,6 @@ { "id": "ltrim#866327adf4da/ansi_off", "reason": "SELECT ltrim(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "ltrim#a24ec608e9eb/ansi_on", - "reason": "SELECT ltrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ltrim#a24ec608e9eb/ansi_off", - "reason": "SELECT ltrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/luhn_check.json b/tests/fixtures/analysis/registry-matrix/luhn_check.json index 08a313972..8446fe4c5 100644 --- a/tests/fixtures/analysis/registry-matrix/luhn_check.json +++ b/tests/fixtures/analysis/registry-matrix/luhn_check.json @@ -15,14 +15,6 @@ { "id": "luhn_check#75f5f800a83b/ansi_off", "reason": "SELECT luhn_check(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "luhn_check#8b95c9c9acc1/ansi_on", - "reason": "SELECT luhn_check(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "luhn_check#8b95c9c9acc1/ansi_off", - "reason": "SELECT luhn_check(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/make_date.json b/tests/fixtures/analysis/registry-matrix/make_date.json index ea615da5c..69e43fa95 100644 --- a/tests/fixtures/analysis/registry-matrix/make_date.json +++ b/tests/fixtures/analysis/registry-matrix/make_date.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "make_date#0a4195c83fd5/ansi_on", - "reason": "SELECT make_date(2013, 7, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "make_date#0a4195c83fd5/ansi_off", - "reason": "SELECT make_date(2013, 7, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "make_date#1845c903c28c/ansi_on", "reason": "SELECT make_date(2013, INTERVAL '1-2' YEAR TO MONTH, 15) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -40,22 +32,6 @@ "id": "make_date#3f5149e89e38/ansi_off", "reason": "SELECT make_date(2013, 7, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "make_date#50045c37172f/ansi_on", - "reason": "SELECT make_date(2013, map('a', 1), 15) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "make_date#50045c37172f/ansi_off", - "reason": "SELECT make_date(2013, map('a', 1), 15) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "make_date#65c3a9e68abf/ansi_on", - "reason": "SELECT make_date(map('a', 1), 7, 15) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "make_date#65c3a9e68abf/ansi_off", - "reason": "SELECT make_date(map('a', 1), 7, 15) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "make_date#dc2fc7038c2e/ansi_on", "reason": "SELECT make_date(2013, 7, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/make_valid_utf8.json b/tests/fixtures/analysis/registry-matrix/make_valid_utf8.json index ee1154f16..14014ed1a 100644 --- a/tests/fixtures/analysis/registry-matrix/make_valid_utf8.json +++ b/tests/fixtures/analysis/registry-matrix/make_valid_utf8.json @@ -8,14 +8,6 @@ "id": "make_valid_utf8#6ebcc233980a/ansi_off", "reason": "SELECT make_valid_utf8(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "make_valid_utf8#a80f6474b021/ansi_on", - "reason": "SELECT make_valid_utf8(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "make_valid_utf8#a80f6474b021/ansi_off", - "reason": "SELECT make_valid_utf8(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "make_valid_utf8#a999163e1d68/ansi_on", "reason": "SELECT make_valid_utf8(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/map.json b/tests/fixtures/analysis/registry-matrix/map.json new file mode 100644 index 000000000..92a41e967 --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map.json @@ -0,0 +1,70 @@ +{ + "entries": [ + { + "id": "map#1bb1231e1797/ansi_on", + "reason": "SELECT map(INTERVAL '1 02:03:04' DAY TO SECOND, '2', 3.0, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#1bb1231e1797/ansi_off", + "reason": "SELECT map(INTERVAL '1 02:03:04' DAY TO SECOND, '2', 3.0, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#2241eabf256c/ansi_on", + "reason": "SELECT map(1.0, '2', INTERVAL '1 02:03:04' DAY TO SECOND, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#2241eabf256c/ansi_off", + "reason": "SELECT map(1.0, '2', INTERVAL '1 02:03:04' DAY TO SECOND, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#304ca4330c39/ansi_on", + "reason": "SELECT map(1.0, '2', 3.0, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "id": "map#304ca4330c39/ansi_off", + "reason": "SELECT map(1.0, '2', 3.0, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" + }, + { + "id": "map#7154d4b8d187/ansi_on", + "reason": "SELECT map(1.0, '2', 3.0, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "id": "map#7154d4b8d187/ansi_off", + "reason": "SELECT map(1.0, '2', 3.0, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" + }, + { + "id": "map#a2e94f046ddf/ansi_on", + "reason": "SELECT map(1.0, INTERVAL '1-2' YEAR TO MONTH, 3.0, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "id": "map#a2e94f046ddf/ansi_off", + "reason": "SELECT map(1.0, INTERVAL '1-2' YEAR TO MONTH, 3.0, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" + }, + { + "id": "map#bfb29042c867/ansi_on", + "reason": "SELECT map(1.0, '2', INTERVAL '1-2' YEAR TO MONTH, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#bfb29042c867/ansi_off", + "reason": "SELECT map(1.0, '2', INTERVAL '1-2' YEAR TO MONTH, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#c96b8f9325c7/ansi_on", + "reason": "SELECT map(INTERVAL '1-2' YEAR TO MONTH, '2', 3.0, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#c96b8f9325c7/ansi_off", + "reason": "SELECT map(INTERVAL '1-2' YEAR TO MONTH, '2', 3.0, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#ec90a5e7058d/ansi_on", + "reason": "SELECT map(1.0, INTERVAL '1 02:03:04' DAY TO SECOND, 3.0, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "id": "map#ec90a5e7058d/ansi_off", + "reason": "SELECT map(1.0, INTERVAL '1 02:03:04' DAY TO SECOND, 3.0, '4') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" + } + ], + "format_version": 1, + "function": "map" +} diff --git a/tests/fixtures/analysis/registry-matrix/map_concat.json b/tests/fixtures/analysis/registry-matrix/map_concat.json new file mode 100644 index 000000000..4136f8a54 --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_concat.json @@ -0,0 +1,38 @@ +{ + "entries": [ + { + "id": "map_concat#627175dd0242/ansi_on", + "reason": "SELECT map_concat(map(1, 'a', 2, 'b'), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#627175dd0242/ansi_off", + "reason": "SELECT map_concat(map(1, 'a', 2, 'b'), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#82683f74a52f/ansi_on", + "reason": "SELECT map_concat(INTERVAL '1 02:03:04' DAY TO SECOND, map(3, 'c')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#82683f74a52f/ansi_off", + "reason": "SELECT map_concat(INTERVAL '1 02:03:04' DAY TO SECOND, map(3, 'c')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#b1105302ff18/ansi_on", + "reason": "SELECT map_concat(INTERVAL '1-2' YEAR TO MONTH, map(3, 'c')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#b1105302ff18/ansi_off", + "reason": "SELECT map_concat(INTERVAL '1-2' YEAR TO MONTH, map(3, 'c')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#f12ffbdf1adc/ansi_on", + "reason": "SELECT map_concat(map(1, 'a', 2, 'b'), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#f12ffbdf1adc/ansi_off", + "reason": "SELECT map_concat(map(1, 'a', 2, 'b'), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + } + ], + "format_version": 1, + "function": "map_concat" +} diff --git a/tests/fixtures/analysis/registry-matrix/map_contains_key.json b/tests/fixtures/analysis/registry-matrix/map_contains_key.json new file mode 100644 index 000000000..c0871215c --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_contains_key.json @@ -0,0 +1,38 @@ +{ + "entries": [ + { + "id": "map_contains_key#7f650ca48c9d/ansi_on", + "reason": "SELECT map_contains_key(INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#7f650ca48c9d/ansi_off", + "reason": "SELECT map_contains_key(INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#b149c52725fe/ansi_on", + "reason": "SELECT map_contains_key(map(1, 'a', 2, 'b'), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#b149c52725fe/ansi_off", + "reason": "SELECT map_contains_key(map(1, 'a', 2, 'b'), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#bc7cc06f4d83/ansi_on", + "reason": "SELECT map_contains_key(map(1, 'a', 2, 'b'), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#bc7cc06f4d83/ansi_off", + "reason": "SELECT map_contains_key(map(1, 'a', 2, 'b'), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#f882e45e927f/ansi_on", + "reason": "SELECT map_contains_key(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#f882e45e927f/ansi_off", + "reason": "SELECT map_contains_key(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + } + ], + "format_version": 1, + "function": "map_contains_key" +} diff --git a/tests/fixtures/analysis/registry-matrix/map_entries.json b/tests/fixtures/analysis/registry-matrix/map_entries.json new file mode 100644 index 000000000..cbb4cf285 --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_entries.json @@ -0,0 +1,22 @@ +{ + "entries": [ + { + "id": "map_entries#11b6abacbd01/ansi_on", + "reason": "SELECT map_entries(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_entries#11b6abacbd01/ansi_off", + "reason": "SELECT map_entries(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_entries#201c3b537851/ansi_on", + "reason": "SELECT map_entries(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_entries#201c3b537851/ansi_off", + "reason": "SELECT map_entries(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + } + ], + "format_version": 1, + "function": "map_entries" +} diff --git a/tests/fixtures/analysis/registry-matrix/map_from_arrays.json b/tests/fixtures/analysis/registry-matrix/map_from_arrays.json new file mode 100644 index 000000000..5fb76559f --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_from_arrays.json @@ -0,0 +1,38 @@ +{ + "entries": [ + { + "id": "map_from_arrays#08636ccc6b7a/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#08636ccc6b7a/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#1cfeee22237b/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#1cfeee22237b/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#bed2f6e41870/ansi_on", + "reason": "SELECT map_from_arrays(INTERVAL '1-2' YEAR TO MONTH, array('2', '4')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#bed2f6e41870/ansi_off", + "reason": "SELECT map_from_arrays(INTERVAL '1-2' YEAR TO MONTH, array('2', '4')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#cb38b6ff0949/ansi_on", + "reason": "SELECT map_from_arrays(INTERVAL '1 02:03:04' DAY TO SECOND, array('2', '4')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#cb38b6ff0949/ansi_off", + "reason": "SELECT map_from_arrays(INTERVAL '1 02:03:04' DAY TO SECOND, array('2', '4')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + } + ], + "format_version": 1, + "function": "map_from_arrays" +} diff --git a/tests/fixtures/analysis/registry-matrix/map_from_entries.json b/tests/fixtures/analysis/registry-matrix/map_from_entries.json new file mode 100644 index 000000000..0f4276e2d --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_from_entries.json @@ -0,0 +1,22 @@ +{ + "entries": [ + { + "id": "map_from_entries#04dd76d47f24/ansi_on", + "reason": "SELECT map_from_entries(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_entries#04dd76d47f24/ansi_off", + "reason": "SELECT map_from_entries(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_entries#9ef22f750186/ansi_on", + "reason": "SELECT map_from_entries(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_entries#9ef22f750186/ansi_off", + "reason": "SELECT map_from_entries(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + } + ], + "format_version": 1, + "function": "map_from_entries" +} diff --git a/tests/fixtures/analysis/registry-matrix/map_keys.json b/tests/fixtures/analysis/registry-matrix/map_keys.json new file mode 100644 index 000000000..4a17b670f --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_keys.json @@ -0,0 +1,22 @@ +{ + "entries": [ + { + "id": "map_keys#25b78e38c59a/ansi_on", + "reason": "SELECT map_keys(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_keys#25b78e38c59a/ansi_off", + "reason": "SELECT map_keys(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_keys#6b41164cbbbe/ansi_on", + "reason": "SELECT map_keys(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_keys#6b41164cbbbe/ansi_off", + "reason": "SELECT map_keys(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + } + ], + "format_version": 1, + "function": "map_keys" +} diff --git a/tests/fixtures/analysis/registry-matrix/map_values.json b/tests/fixtures/analysis/registry-matrix/map_values.json new file mode 100644 index 000000000..d71cb88dd --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_values.json @@ -0,0 +1,22 @@ +{ + "entries": [ + { + "id": "map_values#5b66926a2ac0/ansi_on", + "reason": "SELECT map_values(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_values#5b66926a2ac0/ansi_off", + "reason": "SELECT map_values(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_values#b0ac5e8ef1c2/ansi_on", + "reason": "SELECT map_values(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_values#b0ac5e8ef1c2/ansi_off", + "reason": "SELECT map_values(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + } + ], + "format_version": 1, + "function": "map_values" +} diff --git a/tests/fixtures/analysis/registry-matrix/mask.json b/tests/fixtures/analysis/registry-matrix/mask.json index f419284a0..8e608c7e6 100644 --- a/tests/fixtures/analysis/registry-matrix/mask.json +++ b/tests/fixtures/analysis/registry-matrix/mask.json @@ -1,29 +1,5 @@ { "entries": [ - { - "id": "mask#0219e643dac1/ansi_on", - "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#0219e643dac1/ansi_off", - "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#0ad187a41cfd/ansi_on", - "reason": "SELECT mask('AbCD123-@$#', 'Q', map('a', 1), 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#0ad187a41cfd/ansi_off", - "reason": "SELECT mask('AbCD123-@$#', 'Q', map('a', 1), 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#0afb7427c27e/ansi_on", - "reason": "SELECT mask(map('a', 1), 'Q', 'q', 'd') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#0afb7427c27e/ansi_off", - "reason": "SELECT mask(map('a', 1), 'Q', 'q', 'd') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#0d4a0e4c1460/ansi_on", "reason": "SELECT mask('abcd-EFGH-8765-4321', CAST(X'C328FF' AS STRING)) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.INPUT_SIZE_NOT_ONE" @@ -40,14 +16,6 @@ "id": "mask#185d5f6d23ef/ansi_off", "reason": "SELECT mask(INTERVAL '1 02:03:04' DAY TO SECOND, 'Q', 'q') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "mask#18b2e9921730/ansi_on", - "reason": "SELECT mask('AbCD123-@$#', map('a', 1), 'q') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#18b2e9921730/ansi_off", - "reason": "SELECT mask('AbCD123-@$#', map('a', 1), 'q') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#1c8ecfa526a9/ansi_on", "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -88,14 +56,6 @@ "id": "mask#2f388b8a41ca/ansi_off", "reason": "SELECT mask('', 'Q', 'q', 'd', 'o') | string not null where Spark has string" }, - { - "id": "mask#32a541e4c9d1/ansi_on", - "reason": "SELECT mask(map('a', 1), 'Q', 'q') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#32a541e4c9d1/ansi_off", - "reason": "SELECT mask(map('a', 1), 'Q', 'q') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#341672002912/ansi_on", "reason": "SELECT mask('Ä€日本語😀é', 'Q', 'q', 'd', 'o') | string not null where Spark has string" @@ -104,14 +64,6 @@ "id": "mask#341672002912/ansi_off", "reason": "SELECT mask('Ä€日本語😀é', 'Q', 'q', 'd', 'o') | string not null where Spark has string" }, - { - "id": "mask#347297650062/ansi_on", - "reason": "SELECT mask('AbCD123-@$#', map('a', 1), 'q', 'd') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#347297650062/ansi_off", - "reason": "SELECT mask('AbCD123-@$#', map('a', 1), 'q', 'd') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#38471fc72bbc/ansi_on", "reason": "SELECT mask(' \\t a\\u3000\\n ', 'Q', 'q', 'd', 'o') | string not null where Spark has string" @@ -160,14 +112,6 @@ "id": "mask#4a351acd15c4/ansi_off", "reason": "SELECT mask('AbCD123-@$#', CAST(X'C328FF' AS STRING), 'q', 'd') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.INPUT_SIZE_NOT_ONE" }, - { - "id": "mask#4b44ad3bd540/ansi_on", - "reason": "SELECT mask('AbCD123-@$#', 'Q', map('a', 1), 'd') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#4b44ad3bd540/ansi_off", - "reason": "SELECT mask('AbCD123-@$#', 'Q', map('a', 1), 'd') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#4c3bbabdc2d6/ansi_on", "reason": "SELECT mask('AbCD123-@$#', 'Q', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -184,14 +128,6 @@ "id": "mask#6691f60de573/ansi_off", "reason": "SELECT mask('abcd-EFGH-8765-4321', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "mask#6768bf20f10a/ansi_on", - "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', map('a', 1), 'o') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#6768bf20f10a/ansi_off", - "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', map('a', 1), 'o') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#68f9b5afb88a/ansi_on", "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', CAST(X'C328FF' AS STRING)) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.INPUT_SIZE_NOT_ONE" @@ -232,22 +168,6 @@ "id": "mask#7af2934fee03/ansi_off", "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "mask#7cf541b354af/ansi_on", - "reason": "SELECT mask(map('a', 1), 'Q', 'q', 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#7cf541b354af/ansi_off", - "reason": "SELECT mask(map('a', 1), 'Q', 'q', 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#7e1297a1e2d7/ansi_on", - "reason": "SELECT mask(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#7e1297a1e2d7/ansi_off", - "reason": "SELECT mask(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#7e8b4b5e561c/ansi_on", "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', '1', 'o') | string not null where Spark has string" @@ -256,22 +176,6 @@ "id": "mask#7e8b4b5e561c/ansi_off", "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', '1', 'o') | string not null where Spark has string" }, - { - "id": "mask#7f4b1175ebb0/ansi_on", - "reason": "SELECT mask(map('a', 1), 'Q') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#7f4b1175ebb0/ansi_off", - "reason": "SELECT mask(map('a', 1), 'Q') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#81733105ced5/ansi_on", - "reason": "SELECT mask('abcd-EFGH-8765-4321', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#81733105ced5/ansi_off", - "reason": "SELECT mask('abcd-EFGH-8765-4321', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#8e073509fa76/ansi_on", "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -320,14 +224,6 @@ "id": "mask#a045760f7cbb/ansi_off", "reason": "SELECT mask('AbCD123-@$#', INTERVAL '1 02:03:04' DAY TO SECOND, 'q', 'd') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "mask#a2228ad6d6e9/ansi_on", - "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#a2228ad6d6e9/ansi_off", - "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#a28f7fc11d02/ansi_on", "reason": "SELECT mask('AbCD123-@$#', INTERVAL '1 02:03:04' DAY TO SECOND, 'q', 'd', 'o') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -360,14 +256,6 @@ "id": "mask#aa0f16902a57/ansi_off", "reason": "SELECT mask('AbCD123-@$#', 'Q', CAST(X'C328FF' AS STRING)) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.INPUT_SIZE_NOT_ONE" }, - { - "id": "mask#aa145f72cf15/ansi_on", - "reason": "SELECT mask('AbCD123-@$#', map('a', 1), 'q', 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#aa145f72cf15/ansi_off", - "reason": "SELECT mask('AbCD123-@$#', map('a', 1), 'q', 'd', 'o') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#ab9ccc920439/ansi_on", "reason": "SELECT mask(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -400,14 +288,6 @@ "id": "mask#b107aafe4bec/ansi_off", "reason": "SELECT mask('AbCD123-@$#', 'Q', 'q', INTERVAL '1-2' YEAR TO MONTH, 'o') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "mask#b25f9cdf9495/ansi_on", - "reason": "SELECT mask('AbCD123-@$#', 'Q', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "mask#b25f9cdf9495/ansi_off", - "reason": "SELECT mask('AbCD123-@$#', 'Q', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "mask#b6b4fd6fc340/ansi_on", "reason": "SELECT mask(CAST(X'C328FF' AS STRING), 'Q', 'q', 'd', 'o') | string not null where Spark has string" diff --git a/tests/fixtures/analysis/registry-matrix/max_by.json b/tests/fixtures/analysis/registry-matrix/max_by.json index 24fc550bc..496095dea 100644 --- a/tests/fixtures/analysis/registry-matrix/max_by.json +++ b/tests/fixtures/analysis/registry-matrix/max_by.json @@ -154,11 +154,11 @@ }, { "id": "max_by#c55f1e8b3e18/ansi_on", - "reason": "SELECT max_by(x, y, map('a', 1)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT max_by(x, y, map('a', 1)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "max_by#c55f1e8b3e18/ansi_off", - "reason": "SELECT max_by(x, y, map('a', 1)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT max_by(x, y, map('a', 1)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "max_by#d67b46ca8103/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/md5.json b/tests/fixtures/analysis/registry-matrix/md5.json index 9bf2bdd7e..b77a90a2f 100644 --- a/tests/fixtures/analysis/registry-matrix/md5.json +++ b/tests/fixtures/analysis/registry-matrix/md5.json @@ -8,14 +8,6 @@ "id": "md5#9692b66cda2b/ansi_off", "reason": "SELECT md5(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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#a4ee2af175d3/ansi_off", - "reason": "SELECT md5(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "md5#fd708175c7a6/ansi_on", "reason": "SELECT md5(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/min_by.json b/tests/fixtures/analysis/registry-matrix/min_by.json index 9833f6fbc..54f6ba703 100644 --- a/tests/fixtures/analysis/registry-matrix/min_by.json +++ b/tests/fixtures/analysis/registry-matrix/min_by.json @@ -2,11 +2,11 @@ "entries": [ { "id": "min_by#110479e28bf2/ansi_on", - "reason": "SELECT min_by(x, y, map('a', 1)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT min_by(x, y, map('a', 1)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "min_by#110479e28bf2/ansi_off", - "reason": "SELECT min_by(x, y, map('a', 1)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT min_by(x, y, map('a', 1)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "min_by#1db3db810285/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/minute.json b/tests/fixtures/analysis/registry-matrix/minute.json index 77447b339..26054818b 100644 --- a/tests/fixtures/analysis/registry-matrix/minute.json +++ b/tests/fixtures/analysis/registry-matrix/minute.json @@ -16,14 +16,6 @@ "id": "minute#7dda78084d4d/ansi_off", "reason": "SELECT minute(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "minute#cd42aa4498df/ansi_on", - "reason": "SELECT minute(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "minute#cd42aa4498df/ansi_off", - "reason": "SELECT minute(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "minute#ebcc0b17159f/ansi_on", "reason": "SELECT minute(TIME'23:59:59.999999') | parse: KRISHIV_UNSUPPORTED_FEATURE: TIME literals where Spark has UNSUPPORTED_TIME_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/mod.json b/tests/fixtures/analysis/registry-matrix/mod.json index 4d22cc670..a1164d65e 100644 --- a/tests/fixtures/analysis/registry-matrix/mod.json +++ b/tests/fixtures/analysis/registry-matrix/mod.json @@ -8,14 +8,6 @@ "id": "mod#05114d19d1a3/ansi_off", "reason": "SELECT MOD(INTERVAL '1 02:03:04' DAY TO SECOND, 1.8) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "mod#13cca523c703/ansi_on", - "reason": "SELECT MOD(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "mod#13cca523c703/ansi_off", - "reason": "SELECT MOD(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "mod#2075896cedfc/ansi_off", "reason": "SELECT MOD('1', 1.8) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" @@ -36,14 +28,6 @@ "id": "mod#5fe5533591e7/ansi_off", "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#82d92a551fbf/ansi_on", - "reason": "SELECT MOD(map('a', 1), 1.8) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, { "id": "mod#9d6e70dabb1b/ansi_off", "reason": "SELECT MOD(2, 'abc') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" diff --git a/tests/fixtures/analysis/registry-matrix/month.json b/tests/fixtures/analysis/registry-matrix/month.json index d7e678013..4102c2261 100644 --- a/tests/fixtures/analysis/registry-matrix/month.json +++ b/tests/fixtures/analysis/registry-matrix/month.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "month#50da40137634/ansi_on", - "reason": "SELECT month(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "month#50da40137634/ansi_off", - "reason": "SELECT month(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "month#5f9cb2792de7/ansi_on", "reason": "SELECT month(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/monthname.json b/tests/fixtures/analysis/registry-matrix/monthname.json index 5eb686937..33b2c86a1 100644 --- a/tests/fixtures/analysis/registry-matrix/monthname.json +++ b/tests/fixtures/analysis/registry-matrix/monthname.json @@ -8,14 +8,6 @@ "id": "monthname#3de4a1bb6046/ansi_off", "reason": "SELECT monthname(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "monthname#409d18f8847a/ansi_on", - "reason": "SELECT monthname(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "monthname#409d18f8847a/ansi_off", - "reason": "SELECT monthname(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "monthname#949a9e17e7b8/ansi_on", "reason": "SELECT monthname(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/months_between.json b/tests/fixtures/analysis/registry-matrix/months_between.json index 15b91b0ba..07fe381ae 100644 --- a/tests/fixtures/analysis/registry-matrix/months_between.json +++ b/tests/fixtures/analysis/registry-matrix/months_between.json @@ -8,14 +8,6 @@ "id": "months_between#1cf30befe281/ansi_off", "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "months_between#1de399a111e8/ansi_on", - "reason": "SELECT months_between('1997-02-28 10:30:00', map('a', 1), false) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#1de399a111e8/ansi_off", - "reason": "SELECT months_between('1997-02-28 10:30:00', map('a', 1), false) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "months_between#3b4d3579db12/ansi_on", "reason": "SELECT months_between(INTERVAL '1 02:03:04' DAY TO SECOND, '1996-10-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -60,34 +52,10 @@ "id": "months_between#6955e166bd2c/ansi_off", "reason": "SELECT months_between(INTERVAL '1-2' YEAR TO MONTH, '1996-10-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "months_between#73ccd3b7555a/ansi_on", - "reason": "SELECT months_between(map('a', 1), '1996-10-30') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#73ccd3b7555a/ansi_off", - "reason": "SELECT months_between(map('a', 1), '1996-10-30') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "months_between#80bf50d60eb0/ansi_off", "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', '1') | resolves to double where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "months_between#881804bdfecc/ansi_on", - "reason": "SELECT months_between('1997-02-28 10:30:00', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#881804bdfecc/ansi_off", - "reason": "SELECT months_between('1997-02-28 10:30:00', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#8aeb1b1a9d08/ansi_on", - "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#8aeb1b1a9d08/ansi_off", - "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "months_between#99ba588b014a/ansi_on", "reason": "SELECT months_between(INTERVAL '1 02:03:04' DAY TO SECOND, '1996-10-30', false) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -96,14 +64,6 @@ "id": "months_between#99ba588b014a/ansi_off", "reason": "SELECT months_between(INTERVAL '1 02:03:04' DAY TO SECOND, '1996-10-30', false) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "months_between#ad7e3fced174/ansi_on", - "reason": "SELECT months_between(map('a', 1), '1996-10-30', false) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#ad7e3fced174/ansi_off", - "reason": "SELECT months_between(map('a', 1), '1996-10-30', false) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "months_between#c35328709bd8/ansi_on", "reason": "SELECT months_between(INTERVAL '1-2' YEAR TO MONTH, '1996-10-30', false) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/named_struct.json b/tests/fixtures/analysis/registry-matrix/named_struct.json index 307eff984..913c3af3c 100644 --- a/tests/fixtures/analysis/registry-matrix/named_struct.json +++ b/tests/fixtures/analysis/registry-matrix/named_struct.json @@ -16,14 +16,6 @@ "id": "named_struct#1b1abab9147f/ansi_off", "reason": "SELECT named_struct(\"a\", 1, \"b\", INTERVAL '1 02:03:04' DAY TO SECOND, \"c\", 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "named_struct#20cfff699118/ansi_on", - "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, \"c\", map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "named_struct#20cfff699118/ansi_off", - "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, \"c\", map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, { "id": "named_struct#29ab846d2b3f/ansi_on", "reason": "SELECT named_struct(\"a\", INTERVAL '1 02:03:04' DAY TO SECOND, \"b\", 2, \"c\", 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -56,14 +48,6 @@ "id": "named_struct#4b78ad634ea3/ansi_off", "reason": "SELECT named_struct(INTERVAL '1 02:03:04' DAY TO SECOND, 1, \"b\", 2, \"c\", 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING" }, - { - "id": "named_struct#4cfee24c2fdf/ansi_on", - "reason": "SELECT named_struct(\"a\", 1, map('a', 1), 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING" - }, - { - "id": "named_struct#4cfee24c2fdf/ansi_off", - "reason": "SELECT named_struct(\"a\", 1, map('a', 1), 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING" - }, { "id": "named_struct#522b3a196d19/ansi_on", "reason": "SELECT named_struct(\"a\", INTERVAL '1-2' YEAR TO MONTH, \"b\", 2, \"c\", 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -104,22 +88,6 @@ "id": "named_struct#933fd3e5ff75/ansi_off", "reason": "SELECT named_struct(INTERVAL '1-2' YEAR TO MONTH, 1, \"b\", 2, \"c\", 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING" }, - { - "id": "named_struct#a5000dc6fc02/ansi_on", - "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING" - }, - { - "id": "named_struct#a5000dc6fc02/ansi_off", - "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING" - }, - { - "id": "named_struct#ae007784ea32/ansi_on", - "reason": "SELECT named_struct(\"a\", 1, \"b\", map('a', 1), \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "named_struct#ae007784ea32/ansi_off", - "reason": "SELECT named_struct(\"a\", 1, \"b\", map('a', 1), \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, { "id": "named_struct#c067a5924893/ansi_on", "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, \"c\", INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -136,14 +104,6 @@ "id": "named_struct#ccdc4cc09597/ansi_off", "reason": "SELECT named_struct(CAST(X'C328FF' AS STRING), 1, \"b\", 2, \"c\", 3) | DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING" }, - { - "id": "named_struct#d785d794fd55/ansi_on", - "reason": "SELECT named_struct(\"a\", map('a', 1), \"b\", 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "named_struct#d785d794fd55/ansi_off", - "reason": "SELECT named_struct(\"a\", map('a', 1), \"b\", 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, { "id": "named_struct#e8ebefa519cf/ansi_on", "reason": "SELECT named_struct(\"a\", 1, \"b\", INTERVAL '1-2' YEAR TO MONTH, \"c\", 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -159,14 +119,6 @@ { "id": "named_struct#ea46b2608d1c/ansi_off", "reason": "SELECT named_struct(\"a\", 1, \"b\", 2, INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING" - }, - { - "id": "named_struct#f8c1765df690/ansi_on", - "reason": "SELECT named_struct(map('a', 1), 1, \"b\", 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING" - }, - { - "id": "named_struct#f8c1765df690/ansi_off", - "reason": "SELECT named_struct(map('a', 1), 1, \"b\", 2, \"c\", 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.CREATE_NAMED_STRUCT_WITHOUT_FOLDABLE_STRING" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/nanvl.json b/tests/fixtures/analysis/registry-matrix/nanvl.json index 26c9d0654..338425fc7 100644 --- a/tests/fixtures/analysis/registry-matrix/nanvl.json +++ b/tests/fixtures/analysis/registry-matrix/nanvl.json @@ -8,22 +8,6 @@ "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" }, - { - "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#224c752cdc8a/ansi_off", - "reason": "SELECT nanvl(map('a', 1), 123) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "nanvl#8c6ee640d734/ansi_on", - "reason": "SELECT nanvl(cast('NaN' as double), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "nanvl#8c6ee640d734/ansi_off", - "reason": "SELECT nanvl(cast('NaN' as double), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "nanvl#a22c4b677583/ansi_on", "reason": "SELECT nanvl(INTERVAL '1-2' YEAR TO MONTH, 123) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/negative.json b/tests/fixtures/analysis/registry-matrix/negative.json index 9fd2d3f69..9516b5979 100644 --- a/tests/fixtures/analysis/registry-matrix/negative.json +++ b/tests/fixtures/analysis/registry-matrix/negative.json @@ -8,14 +8,6 @@ "id": "negative#987900a6d6ac/ansi_off", "reason": "SELECT negative(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "negative#c4238766e626/ansi_on", - "reason": "SELECT negative(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "negative#c4238766e626/ansi_off", - "reason": "SELECT negative(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "negative#e4f95c990089/ansi_on", "reason": "SELECT negative(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/next_day.json b/tests/fixtures/analysis/registry-matrix/next_day.json index e2dcbe15f..20f640bff 100644 --- a/tests/fixtures/analysis/registry-matrix/next_day.json +++ b/tests/fixtures/analysis/registry-matrix/next_day.json @@ -16,22 +16,6 @@ "id": "next_day#2096fcf1af34/ansi_off", "reason": "SELECT next_day('2015-01-14', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "next_day#440d78eca0dd/ansi_on", - "reason": "SELECT next_day(map('a', 1), 'TU') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "next_day#440d78eca0dd/ansi_off", - "reason": "SELECT next_day(map('a', 1), 'TU') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "next_day#a1ede256fcb7/ansi_on", - "reason": "SELECT next_day('2015-01-14', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "next_day#a1ede256fcb7/ansi_off", - "reason": "SELECT next_day('2015-01-14', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "next_day#a62742e67e42/ansi_on", "reason": "SELECT next_day(INTERVAL '1-2' YEAR TO MONTH, 'TU') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/nth_value.json b/tests/fixtures/analysis/registry-matrix/nth_value.json index 43c833232..53a01a106 100644 --- a/tests/fixtures/analysis/registry-matrix/nth_value.json +++ b/tests/fixtures/analysis/registry-matrix/nth_value.json @@ -78,11 +78,11 @@ }, { "id": "nth_value#ebc0f47db606/ansi_on", - "reason": "SELECT a, b, nth_value(b, map('a', 1)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT a, b, nth_value(b, map('a', 1)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "nth_value#ebc0f47db606/ansi_off", - "reason": "SELECT a, b, nth_value(b, map('a', 1)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT a, b, nth_value(b, map('a', 1)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/ntile.json b/tests/fixtures/analysis/registry-matrix/ntile.json index be33d7d35..4a375f2f6 100644 --- a/tests/fixtures/analysis/registry-matrix/ntile.json +++ b/tests/fixtures/analysis/registry-matrix/ntile.json @@ -66,11 +66,11 @@ }, { "id": "ntile#fa460a3ff5bc/ansi_on", - "reason": "SELECT a, b, ntile(map('a', 1)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT a, b, ntile(map('a', 1)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "ntile#fa460a3ff5bc/ansi_off", - "reason": "SELECT a, b, ntile(map('a', 1)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT a, b, ntile(map('a', 1)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/nullif.json b/tests/fixtures/analysis/registry-matrix/nullif.json index 3b96ec914..1e39805fd 100644 --- a/tests/fixtures/analysis/registry-matrix/nullif.json +++ b/tests/fixtures/analysis/registry-matrix/nullif.json @@ -1,21 +1,5 @@ { "entries": [ - { - "id": "nullif#8c6ac4b1f807/ansi_on", - "reason": "SELECT nullif(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "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" - }, - { - "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#9e38d7ab0840/ansi_off", - "reason": "SELECT nullif(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "nullif#b1219b8ebaad/ansi_on", "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" diff --git a/tests/fixtures/analysis/registry-matrix/nullifzero.json b/tests/fixtures/analysis/registry-matrix/nullifzero.json index 5e7e1df51..26ce9c92a 100644 --- a/tests/fixtures/analysis/registry-matrix/nullifzero.json +++ b/tests/fixtures/analysis/registry-matrix/nullifzero.json @@ -8,14 +8,6 @@ "id": "nullifzero#92aa389f4ff9/ansi_off", "reason": "SELECT nullifzero(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "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#b2fca9a991cf/ansi_off", - "reason": "SELECT nullifzero(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "nullifzero#f0aba72ce40b/ansi_on", "reason": "SELECT nullifzero(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/nvl.json b/tests/fixtures/analysis/registry-matrix/nvl.json index c806c9ebb..598059fbe 100644 --- a/tests/fixtures/analysis/registry-matrix/nvl.json +++ b/tests/fixtures/analysis/registry-matrix/nvl.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "nvl#13de9ce1fe22/ansi_on", - "reason": "SELECT nvl(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#13de9ce1fe22/ansi_off", - "reason": "SELECT nvl(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl#9e1045de78bd/ansi_on", "reason": "SELECT nvl(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -39,14 +31,6 @@ { "id": "nvl#e0e8f9112791/ansi_off", "reason": "SELECT nvl(INTERVAL '1-2' YEAR TO MONTH, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#fd2b816559e6/ansi_on", - "reason": "SELECT nvl(NULL, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "nvl#fd2b816559e6/ansi_off", - "reason": "SELECT nvl(NULL, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/nvl2.json b/tests/fixtures/analysis/registry-matrix/nvl2.json index 2c19d17c9..9305b308e 100644 --- a/tests/fixtures/analysis/registry-matrix/nvl2.json +++ b/tests/fixtures/analysis/registry-matrix/nvl2.json @@ -16,14 +16,6 @@ "id": "nvl2#239048a3bfae/ansi_off", "reason": "SELECT nvl2(INTERVAL '1-2' YEAR TO MONTH, 2, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "nvl2#92c35e6b7596/ansi_on", - "reason": "SELECT nvl2(NULL, map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl2#92c35e6b7596/ansi_off", - "reason": "SELECT nvl2(NULL, map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl2#9537be4ef8c8/ansi_on", "reason": "SELECT nvl2(NULL, 2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -40,22 +32,6 @@ "id": "nvl2#997859899362/ansi_off", "reason": "SELECT nvl2(NULL, 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "nvl2#9987e2ffcc74/ansi_on", - "reason": "SELECT nvl2(map('a', 1), 2, 1) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "nvl2#9987e2ffcc74/ansi_off", - "reason": "SELECT nvl2(map('a', 1), 2, 1) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "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#b713cf78a1f7/ansi_off", - "reason": "SELECT nvl2(NULL, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl2#d68aaefed581/ansi_on", "reason": "SELECT nvl2(NULL, INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/octet_length.json b/tests/fixtures/analysis/registry-matrix/octet_length.json index 32b49f94c..6f2fb2487 100644 --- a/tests/fixtures/analysis/registry-matrix/octet_length.json +++ b/tests/fixtures/analysis/registry-matrix/octet_length.json @@ -8,14 +8,6 @@ "id": "octet_length#4a19477b96a3/ansi_off", "reason": "SELECT octet_length(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "octet_length#98284060128c/ansi_on", - "reason": "SELECT octet_length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "octet_length#98284060128c/ansi_off", - "reason": "SELECT octet_length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "octet_length#f5ac9fab278a/ansi_on", "reason": "SELECT octet_length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/parse_url.json b/tests/fixtures/analysis/registry-matrix/parse_url.json index 5978ffbd6..798b85272 100644 --- a/tests/fixtures/analysis/registry-matrix/parse_url.json +++ b/tests/fixtures/analysis/registry-matrix/parse_url.json @@ -16,14 +16,6 @@ "id": "parse_url#67e01ef0140a/ansi_off", "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "parse_url#6a6783c67e72/ansi_on", - "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "parse_url#6a6783c67e72/ansi_off", - "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "parse_url#7e07c0898f86/ansi_on", "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,22 +24,6 @@ "id": "parse_url#7e07c0898f86/ansi_off", "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "parse_url#81533c28fb16/ansi_on", - "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "parse_url#81533c28fb16/ansi_off", - "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "parse_url#85e9171235fd/ansi_on", - "reason": "SELECT parse_url(map('a', 1), 'HOST') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "parse_url#85e9171235fd/ansi_off", - "reason": "SELECT parse_url(map('a', 1), 'HOST') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "parse_url#8d44c1f74ada/ansi_on", "reason": "SELECT parse_url(INTERVAL '1-2' YEAR TO MONTH, 'QUERY', 'query') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -72,22 +48,6 @@ "id": "parse_url#c943054aa066/ansi_off", "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "parse_url#c9d56ad4c5d4/ansi_on", - "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', map('a', 1), 'query') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "parse_url#c9d56ad4c5d4/ansi_off", - "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', map('a', 1), 'query') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "parse_url#ce48003b52e3/ansi_on", - "reason": "SELECT parse_url(map('a', 1), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "parse_url#ce48003b52e3/ansi_off", - "reason": "SELECT parse_url(map('a', 1), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "parse_url#d412104dc89e/ansi_on", "reason": "SELECT parse_url(INTERVAL '1 02:03:04' DAY TO SECOND, 'HOST') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/pmod.json b/tests/fixtures/analysis/registry-matrix/pmod.json index 2ee984598..a78b8124c 100644 --- a/tests/fixtures/analysis/registry-matrix/pmod.json +++ b/tests/fixtures/analysis/registry-matrix/pmod.json @@ -32,22 +32,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#aecf0980d9f7/ansi_on", - "reason": "SELECT pmod(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, - { - "id": "pmod#af546d50231a/ansi_on", - "reason": "SELECT pmod(10, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "pmod#af546d50231a/ansi_off", - "reason": "SELECT pmod(10, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "pmod#eabcafc29524/ansi_on", "reason": "SELECT pmod(10, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/position.json b/tests/fixtures/analysis/registry-matrix/position.json index 47a849dba..fc7a356c1 100644 --- a/tests/fixtures/analysis/registry-matrix/position.json +++ b/tests/fixtures/analysis/registry-matrix/position.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "position#09c5e86aaead/ansi_on", - "reason": "SELECT position('bar', 'foobarbar', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "position#09c5e86aaead/ansi_off", - "reason": "SELECT position('bar', 'foobarbar', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "position#401cb85e8a92/ansi_on", "reason": "SELECT position('bar', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -16,14 +8,6 @@ "id": "position#401cb85e8a92/ansi_off", "reason": "SELECT position('bar', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "position#435da456c2db/ansi_on", - "reason": "SELECT position(map('a', 1), 'foobarbar', 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "position#435da456c2db/ansi_off", - "reason": "SELECT position(map('a', 1), 'foobarbar', 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "position#45b179968e70/ansi_on", "reason": "SELECT position('bar', 'foobarbar', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +16,6 @@ "id": "position#45b179968e70/ansi_off", "reason": "SELECT position('bar', 'foobarbar', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "position#5a191672b74d/ansi_on", - "reason": "SELECT position(map('a', 1), 'foobarbar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "position#5a191672b74d/ansi_off", - "reason": "SELECT position(map('a', 1), 'foobarbar') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "position#7d3113d0d8c7/ansi_on", "reason": "SELECT position('bar', INTERVAL '1-2' YEAR TO MONTH, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -48,14 +24,6 @@ "id": "position#7d3113d0d8c7/ansi_off", "reason": "SELECT position('bar', INTERVAL '1-2' YEAR TO MONTH, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "position#7dd7c5d12ea4/ansi_on", - "reason": "SELECT position('bar', map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "position#7dd7c5d12ea4/ansi_off", - "reason": "SELECT position('bar', map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "position#8062b7f85e1f/ansi_on", "reason": "SELECT position('bar', 'foobarbar', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +32,6 @@ "id": "position#8062b7f85e1f/ansi_off", "reason": "SELECT position('bar', 'foobarbar', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "position#a0a0f6b178ad/ansi_on", - "reason": "SELECT position('bar', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "position#a0a0f6b178ad/ansi_off", - "reason": "SELECT position('bar', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "position#a474bf49e08d/ansi_on", "reason": "SELECT position(INTERVAL '1-2' YEAR TO MONTH, 'foobarbar', 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/positive.json b/tests/fixtures/analysis/registry-matrix/positive.json index bbc91b097..ac6304589 100644 --- a/tests/fixtures/analysis/registry-matrix/positive.json +++ b/tests/fixtures/analysis/registry-matrix/positive.json @@ -15,14 +15,6 @@ { "id": "positive#800db4352ef6/ansi_off", "reason": "SELECT positive(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "positive#871141615963/ansi_on", - "reason": "SELECT positive(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "positive#871141615963/ansi_off", - "reason": "SELECT positive(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/pow.json b/tests/fixtures/analysis/registry-matrix/pow.json index d6a7ab9b0..6ec92b51b 100644 --- a/tests/fixtures/analysis/registry-matrix/pow.json +++ b/tests/fixtures/analysis/registry-matrix/pow.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "pow#0a1c1e8c1dd4/ansi_on", - "reason": "SELECT pow(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "pow#0a1c1e8c1dd4/ansi_off", - "reason": "SELECT pow(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "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" @@ -16,14 +8,6 @@ "id": "pow#0ebc9f0c4365/ansi_off", "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#68ef202493af/ansi_on", - "reason": "SELECT pow(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "pow#68ef202493af/ansi_off", - "reason": "SELECT pow(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "pow#6e2b7ff3457e/ansi_on", "reason": "SELECT pow(INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/power.json b/tests/fixtures/analysis/registry-matrix/power.json index b544a575c..fa4e79793 100644 --- a/tests/fixtures/analysis/registry-matrix/power.json +++ b/tests/fixtures/analysis/registry-matrix/power.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "power#50aa498e03a3/ansi_on", - "reason": "SELECT power(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "power#50aa498e03a3/ansi_off", - "reason": "SELECT power(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "power#545aa427d3a7/ansi_on", "reason": "SELECT power(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -39,14 +31,6 @@ { "id": "power#d19c56950ea8/ansi_off", "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#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#f93ad7c3e8b6/ansi_off", - "reason": "SELECT power(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/quarter.json b/tests/fixtures/analysis/registry-matrix/quarter.json index f006e81b0..c12704674 100644 --- a/tests/fixtures/analysis/registry-matrix/quarter.json +++ b/tests/fixtures/analysis/registry-matrix/quarter.json @@ -8,14 +8,6 @@ "id": "quarter#33f96398e51b/ansi_off", "reason": "SELECT quarter(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "quarter#547b07ab9609/ansi_on", - "reason": "SELECT quarter(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "quarter#547b07ab9609/ansi_off", - "reason": "SELECT quarter(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "quarter#7e5e4bb0baa2/ansi_on", "reason": "SELECT quarter(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/quote.json b/tests/fixtures/analysis/registry-matrix/quote.json index 86d116461..8408d757a 100644 --- a/tests/fixtures/analysis/registry-matrix/quote.json +++ b/tests/fixtures/analysis/registry-matrix/quote.json @@ -15,14 +15,6 @@ { "id": "quote#45b899b5afde/ansi_off", "reason": "SELECT quote(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "quote#e072b999e0ab/ansi_on", - "reason": "SELECT quote(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "quote#e072b999e0ab/ansi_off", - "reason": "SELECT quote(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/radians.json b/tests/fixtures/analysis/registry-matrix/radians.json index cadb278fd..aa69095c3 100644 --- a/tests/fixtures/analysis/registry-matrix/radians.json +++ b/tests/fixtures/analysis/registry-matrix/radians.json @@ -1,13 +1,5 @@ { "entries": [ - { - "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#a6b560943a35/ansi_off", - "reason": "SELECT radians(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "radians#de989828ff4d/ansi_on", "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" diff --git a/tests/fixtures/analysis/registry-matrix/raise_error.json b/tests/fixtures/analysis/registry-matrix/raise_error.json index e790d810e..095ab836c 100644 --- a/tests/fixtures/analysis/registry-matrix/raise_error.json +++ b/tests/fixtures/analysis/registry-matrix/raise_error.json @@ -15,14 +15,6 @@ { "id": "raise_error#30a64ebeeb6a/ansi_off", "reason": "SELECT raise_error(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "raise_error#7316fcbbf706/ansi_on", - "reason": "SELECT raise_error(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "raise_error#7316fcbbf706/ansi_off", - "reason": "SELECT raise_error(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/rand.json b/tests/fixtures/analysis/registry-matrix/rand.json index 610f5ddb6..b042bca0f 100644 --- a/tests/fixtures/analysis/registry-matrix/rand.json +++ b/tests/fixtures/analysis/registry-matrix/rand.json @@ -15,14 +15,6 @@ { "id": "rand#2883ca45911e/ansi_off", "reason": "SELECT rand(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rand#a4f856765524/ansi_on", - "reason": "SELECT rand(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rand#a4f856765524/ansi_off", - "reason": "SELECT rand(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/randn.json b/tests/fixtures/analysis/registry-matrix/randn.json index 5fcb326f1..29d4aa663 100644 --- a/tests/fixtures/analysis/registry-matrix/randn.json +++ b/tests/fixtures/analysis/registry-matrix/randn.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "randn#8df4dfcb761d/ansi_on", - "reason": "SELECT randn(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "randn#8df4dfcb761d/ansi_off", - "reason": "SELECT randn(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "randn#905f1cb314d6/ansi_on", "reason": "SELECT randn(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/random.json b/tests/fixtures/analysis/registry-matrix/random.json index dab9bc0cd..171770ae3 100644 --- a/tests/fixtures/analysis/registry-matrix/random.json +++ b/tests/fixtures/analysis/registry-matrix/random.json @@ -15,14 +15,6 @@ { "id": "random#73bb8aca50b7/ansi_off", "reason": "SELECT random(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "random#b218d468723d/ansi_on", - "reason": "SELECT random(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "random#b218d468723d/ansi_off", - "reason": "SELECT random(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/randstr.json b/tests/fixtures/analysis/registry-matrix/randstr.json index 81e46a666..80b2d70cb 100644 --- a/tests/fixtures/analysis/registry-matrix/randstr.json +++ b/tests/fixtures/analysis/registry-matrix/randstr.json @@ -16,14 +16,6 @@ "id": "randstr#55df7b2e1334/ansi_off", "reason": "SELECT randstr(3, INTERVAL '1 02:03:04' DAY TO SECOND) AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "randstr#9e4c25337d0d/ansi_on", - "reason": "SELECT randstr(map('a', 1), 0) AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "randstr#9e4c25337d0d/ansi_off", - "reason": "SELECT randstr(map('a', 1), 0) AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "randstr#a0e222978047/ansi_on", "reason": "SELECT randstr(INTERVAL '1 02:03:04' DAY TO SECOND, 0) AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "randstr#a0e222978047/ansi_off", "reason": "SELECT randstr(INTERVAL '1 02:03:04' DAY TO SECOND, 0) AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "randstr#d06ac69e5e3a/ansi_on", - "reason": "SELECT randstr(3, map('a', 1)) AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "randstr#d06ac69e5e3a/ansi_off", - "reason": "SELECT randstr(3, map('a', 1)) AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "randstr#e2c6f88c4702/ansi_on", "reason": "SELECT randstr(INTERVAL '1-2' YEAR TO MONTH, 0) AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/regexp.json b/tests/fixtures/analysis/registry-matrix/regexp.json index db18900bc..25f0096be 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp.json +++ b/tests/fixtures/analysis/registry-matrix/regexp.json @@ -31,22 +31,6 @@ { "id": "regexp#75f562e9a5ab/ansi_off", "reason": "SELECT regexp(INTERVAL '1 02:03:04' DAY TO SECOND, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "regexp#7a9373d75338/ansi_on", - "reason": "SELECT regexp('%SystemDrive%\\Users\\John', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp#7a9373d75338/ansi_off", - "reason": "SELECT regexp('%SystemDrive%\\Users\\John', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp#f2d787a50f4c/ansi_on", - "reason": "SELECT regexp(map('a', 1), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp#f2d787a50f4c/ansi_off", - "reason": "SELECT regexp(map('a', 1), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/regexp_count.json b/tests/fixtures/analysis/registry-matrix/regexp_count.json index 2fd277e3d..59970b6bd 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_count.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_count.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "regexp_count#0afc8da34f72/ansi_on", - "reason": "SELECT regexp_count(map('a', 1), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_count#0afc8da34f72/ansi_off", - "reason": "SELECT regexp_count(map('a', 1), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_count#10f4912f6ce6/ansi_on", "reason": "SELECT regexp_count(INTERVAL '1-2' YEAR TO MONTH, 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -39,14 +31,6 @@ { "id": "regexp_count#4e5127786dc5/ansi_off", "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "regexp_count#e50fca3b8f7b/ansi_on", - "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_count#e50fca3b8f7b/ansi_off", - "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/regexp_extract.json b/tests/fixtures/analysis/registry-matrix/regexp_extract.json index 2074f6b7f..32079b0f1 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_extract.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_extract.json @@ -8,14 +8,6 @@ "id": "regexp_extract#0106750a1e73/ansi_off", "reason": "SELECT regexp_extract(INTERVAL '1 02:03:04' DAY TO SECOND, '(\\\\d+)-(\\\\d+)', 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "regexp_extract#17d1cf23ebb1/ansi_on", - "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_extract#17d1cf23ebb1/ansi_off", - "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_extract#30b54cc8b365/ansi_on", "reason": "SELECT regexp_extract('100-200', INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -55,22 +47,6 @@ { "id": "regexp_extract#a1bd824c3f9d/ansi_off", "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_extract#a63edbab1015/ansi_on", - "reason": "SELECT regexp_extract('100-200', map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_extract#a63edbab1015/ansi_off", - "reason": "SELECT regexp_extract('100-200', map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_extract#e4b7e0aa5c1b/ansi_on", - "reason": "SELECT regexp_extract(map('a', 1), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_extract#e4b7e0aa5c1b/ansi_off", - "reason": "SELECT regexp_extract(map('a', 1), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/regexp_instr.json b/tests/fixtures/analysis/registry-matrix/regexp_instr.json index 5cd72aae7..4b3c99a80 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_instr.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_instr.json @@ -16,14 +16,6 @@ "id": "regexp_instr#1fdeb48d1ede/ansi_off", "reason": "SELECT regexp_instr(r\"\\abc\", INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "regexp_instr#2faa36b849a1/ansi_on", - "reason": "SELECT regexp_instr(r\"\\abc\", map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_instr#2faa36b849a1/ansi_off", - "reason": "SELECT regexp_instr(r\"\\abc\", map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_instr#92709d4e5bb3/ansi_on", "reason": "SELECT regexp_instr(INTERVAL '1-2' YEAR TO MONTH, r\"^\\\\abc$\") | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -32,14 +24,6 @@ "id": "regexp_instr#92709d4e5bb3/ansi_off", "reason": "SELECT regexp_instr(INTERVAL '1-2' YEAR TO MONTH, r\"^\\\\abc$\") | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "regexp_instr#a177fdc18858/ansi_on", - "reason": "SELECT regexp_instr(map('a', 1), r\"^\\\\abc$\") | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_instr#a177fdc18858/ansi_off", - "reason": "SELECT regexp_instr(map('a', 1), r\"^\\\\abc$\") | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_instr#e495063cde68/ansi_on", "reason": "SELECT regexp_instr(r\"\\abc\", INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/regexp_like.json b/tests/fixtures/analysis/registry-matrix/regexp_like.json index 75073ddfd..2dce7a629 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_like.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_like.json @@ -16,22 +16,6 @@ "id": "regexp_like#55ca391fec1c/ansi_off", "reason": "SELECT regexp_like(INTERVAL '1 02:03:04' DAY TO SECOND, '%SystemDrive%\\\\Users.*') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "regexp_like#84a661eb1231/ansi_on", - "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_like#84a661eb1231/ansi_off", - "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_like#8ed857c04e18/ansi_on", - "reason": "SELECT regexp_like(map('a', 1), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_like#8ed857c04e18/ansi_off", - "reason": "SELECT regexp_like(map('a', 1), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_like#9f58a004fc29/ansi_on", "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/regexp_replace.json b/tests/fixtures/analysis/registry-matrix/regexp_replace.json index 6faf1c92d..8e9d6023f 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_replace.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_replace.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "regexp_replace#074e6419593f/ansi_on", - "reason": "SELECT regexp_replace(map('a', 1), '(\\\\d+)', 'num') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_replace#074e6419593f/ansi_off", - "reason": "SELECT regexp_replace(map('a', 1), '(\\\\d+)', 'num') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_replace#1043ae0b689c/ansi_on", "reason": "SELECT regexp_replace('100-200', INTERVAL '1-2' YEAR TO MONTH, 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -40,22 +32,6 @@ "id": "regexp_replace#44c18601c5b8/ansi_off", "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "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#4554f98913c4/ansi_off", - "reason": "SELECT regexp_replace('100-200', map('a', 1), 'num') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_replace#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#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" - }, { "id": "regexp_replace#d882b6eb34c6/ansi_on", "reason": "SELECT regexp_replace('100-200', INTERVAL '1 02:03:04' DAY TO SECOND, 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/regexp_substr.json b/tests/fixtures/analysis/registry-matrix/regexp_substr.json index 814508cfd..a119d58a6 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_substr.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_substr.json @@ -31,22 +31,6 @@ { "id": "regexp_substr#892ffdc712e7/ansi_off", "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "regexp_substr#cc9e77840c0c/ansi_on", - "reason": "SELECT regexp_substr(map('a', 1), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_substr#cc9e77840c0c/ansi_off", - "reason": "SELECT regexp_substr(map('a', 1), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_substr#cd1b17330070/ansi_on", - "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_substr#cd1b17330070/ansi_off", - "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/repeat.json b/tests/fixtures/analysis/registry-matrix/repeat.json index 64136c126..577fd0cd8 100644 --- a/tests/fixtures/analysis/registry-matrix/repeat.json +++ b/tests/fixtures/analysis/registry-matrix/repeat.json @@ -16,22 +16,6 @@ "id": "repeat#86be454ecd74/ansi_off", "reason": "SELECT repeat(INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "repeat#9526cafc7467/ansi_on", - "reason": "SELECT repeat('123', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "repeat#9526cafc7467/ansi_off", - "reason": "SELECT repeat('123', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "repeat#9a1782197783/ansi_on", - "reason": "SELECT repeat(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "repeat#9a1782197783/ansi_off", - "reason": "SELECT repeat(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "repeat#bb2d12b4940f/ansi_on", "reason": "SELECT repeat('123', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/replace.json b/tests/fixtures/analysis/registry-matrix/replace.json index fa5eff5de..49663805c 100644 --- a/tests/fixtures/analysis/registry-matrix/replace.json +++ b/tests/fixtures/analysis/registry-matrix/replace.json @@ -8,14 +8,6 @@ "id": "replace#5c277e88fd2d/ansi_off", "reason": "SELECT replace('ABCabc', 'abc', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "replace#773d4608b460/ansi_on", - "reason": "SELECT replace('ABCabc', 'abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "replace#773d4608b460/ansi_off", - "reason": "SELECT replace('ABCabc', 'abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "replace#8abe9653048f/ansi_on", "reason": "SELECT replace('ABCabc', INTERVAL '1 02:03:04' DAY TO SECOND, 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -24,14 +16,6 @@ "id": "replace#8abe9653048f/ansi_off", "reason": "SELECT replace('ABCabc', INTERVAL '1 02:03:04' DAY TO SECOND, 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "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#8f3797458fc0/ansi_off", - "reason": "SELECT replace(map('a', 1), 'abc', 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "replace#b4f9fb44df97/ansi_on", "reason": "SELECT replace('ABCabc', INTERVAL '1-2' YEAR TO MONTH, 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -48,14 +32,6 @@ "id": "replace#bc3da4b48ee0/ansi_off", "reason": "SELECT replace(INTERVAL '1 02:03:04' DAY TO SECOND, 'abc', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "replace#d9f91490acc7/ansi_on", - "reason": "SELECT replace('ABCabc', map('a', 1), 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "replace#d9f91490acc7/ansi_off", - "reason": "SELECT replace('ABCabc', map('a', 1), 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "replace#e9035df3e654/ansi_on", "reason": "SELECT replace(INTERVAL '1-2' YEAR TO MONTH, 'abc', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/reverse.json b/tests/fixtures/analysis/registry-matrix/reverse.json index c2a3e663d..d42848e81 100644 --- a/tests/fixtures/analysis/registry-matrix/reverse.json +++ b/tests/fixtures/analysis/registry-matrix/reverse.json @@ -48,14 +48,6 @@ "id": "reverse#b32c7db50969/ansi_off", "reason": "SELECT reverse(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "reverse#bd5605d2bf87/ansi_on", - "reason": "SELECT reverse(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "reverse#bd5605d2bf87/ansi_off", - "reason": "SELECT reverse(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "reverse#c0dc5ee20538/ansi_on", "reason": "SELECT reverse(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/right.json b/tests/fixtures/analysis/registry-matrix/right.json index 7a7bdba84..b182ef658 100644 --- a/tests/fixtures/analysis/registry-matrix/right.json +++ b/tests/fixtures/analysis/registry-matrix/right.json @@ -16,14 +16,6 @@ "id": "right#4d2be744657b/ansi_off", "reason": "SELECT right('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "right#5127880e4906/ansi_on", - "reason": "SELECT right(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "right#5127880e4906/ansi_off", - "reason": "SELECT right(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "right#5672f4c19c3c/ansi_on", "reason": "SELECT right('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "right#5672f4c19c3c/ansi_off", "reason": "SELECT right('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "right#a05d0302bdb5/ansi_on", - "reason": "SELECT right('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "right#a05d0302bdb5/ansi_off", - "reason": "SELECT right('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "right#f10f3e53b1e8/ansi_on", "reason": "SELECT right(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/rint.json b/tests/fixtures/analysis/registry-matrix/rint.json index 15b909b93..651ac544b 100644 --- a/tests/fixtures/analysis/registry-matrix/rint.json +++ b/tests/fixtures/analysis/registry-matrix/rint.json @@ -15,14 +15,6 @@ { "id": "rint#d8c12bef3602/ansi_off", "reason": "SELECT rint(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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": "rint#eb2ae54d30a3/ansi_off", - "reason": "SELECT rint(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/round.json b/tests/fixtures/analysis/registry-matrix/round.json index 472882bef..cb6a62609 100644 --- a/tests/fixtures/analysis/registry-matrix/round.json +++ b/tests/fixtures/analysis/registry-matrix/round.json @@ -31,22 +31,6 @@ { "id": "round#a6a1524bee2c/ansi_off", "reason": "SELECT round(INTERVAL '1-2' YEAR TO MONTH, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#b34b11863015/ansi_off", - "reason": "SELECT round(2.5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "round#efef4a884ef2/ansi_on", - "reason": "SELECT round(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/rpad.json b/tests/fixtures/analysis/registry-matrix/rpad.json index 18f2a3740..c07ff628b 100644 --- a/tests/fixtures/analysis/registry-matrix/rpad.json +++ b/tests/fixtures/analysis/registry-matrix/rpad.json @@ -8,14 +8,6 @@ "id": "rpad#01185a535503/ansi_off", "reason": "SELECT rpad('hi', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "rpad#0bf1aa70ff76/ansi_on", - "reason": "SELECT rpad('hi', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rpad#0bf1aa70ff76/ansi_off", - "reason": "SELECT rpad('hi', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "rpad#0dde82949852/ansi_on", "reason": "SELECT rpad('hi', INTERVAL '1 02:03:04' DAY TO SECOND, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -40,22 +32,6 @@ "id": "rpad#2df795636485/ansi_off", "reason": "SELECT rpad('hi', 5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "rpad#7acc254d2875/ansi_on", - "reason": "SELECT rpad(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, - { - "id": "rpad#7e928e3e1889/ansi_on", - "reason": "SELECT rpad('hi', map('a', 1), '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rpad#7e928e3e1889/ansi_off", - "reason": "SELECT rpad('hi', map('a', 1), '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "rpad#888e9eeec49f/ansi_on", "reason": "SELECT rpad(INTERVAL '1 02:03:04' DAY TO SECOND, 5, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -96,22 +72,6 @@ "id": "rpad#c2dc63c23dd1/ansi_off", "reason": "SELECT rpad('hi', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "rpad#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#d8ee019cf6cd/ansi_off", - "reason": "SELECT rpad('hi', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rpad#f3cf473e2510/ansi_on", - "reason": "SELECT rpad(map('a', 1), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" - }, { "id": "rpad#f654cde77e9c/ansi_on", "reason": "SELECT rpad(INTERVAL '1 02:03:04' DAY TO SECOND, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/rtrim.json b/tests/fixtures/analysis/registry-matrix/rtrim.json index 33ae10d7f..bf00a9526 100644 --- a/tests/fixtures/analysis/registry-matrix/rtrim.json +++ b/tests/fixtures/analysis/registry-matrix/rtrim.json @@ -8,14 +8,6 @@ "id": "rtrim#1737a0f2a2dc/ansi_off", "reason": "SELECT rtrim(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "rtrim#4f1bf1caadb5/ansi_on", - "reason": "SELECT rtrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rtrim#4f1bf1caadb5/ansi_off", - "reason": "SELECT rtrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "rtrim#e2250baced2d/ansi_on", "reason": "SELECT rtrim(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/schema_of_csv.json b/tests/fixtures/analysis/registry-matrix/schema_of_csv.json index aeeea7275..1894ae126 100644 --- a/tests/fixtures/analysis/registry-matrix/schema_of_csv.json +++ b/tests/fixtures/analysis/registry-matrix/schema_of_csv.json @@ -10,11 +10,11 @@ }, { "id": "schema_of_csv#6dd58f097201/ansi_on", - "reason": "SELECT schema_of_csv(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT schema_of_csv(map('a', 1)) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "schema_of_csv#6dd58f097201/ansi_off", - "reason": "SELECT schema_of_csv(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT schema_of_csv(map('a', 1)) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "schema_of_csv#738ea2cc8e60/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/sec.json b/tests/fixtures/analysis/registry-matrix/sec.json index 91ccb91be..3c46a8bfa 100644 --- a/tests/fixtures/analysis/registry-matrix/sec.json +++ b/tests/fixtures/analysis/registry-matrix/sec.json @@ -15,14 +15,6 @@ { "id": "sec#addf508f6552/ansi_off", "reason": "SELECT sec(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#c2e9bb28ade3/ansi_off", - "reason": "SELECT sec(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/second.json b/tests/fixtures/analysis/registry-matrix/second.json index d312cf523..4ad3c36bb 100644 --- a/tests/fixtures/analysis/registry-matrix/second.json +++ b/tests/fixtures/analysis/registry-matrix/second.json @@ -31,14 +31,6 @@ { "id": "second#ade2ed5d7b44/ansi_off", "reason": "SELECT second(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "second#edf06afe63c6/ansi_on", - "reason": "SELECT second(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "second#edf06afe63c6/ansi_off", - "reason": "SELECT second(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/sha.json b/tests/fixtures/analysis/registry-matrix/sha.json index f3428ec10..9f85c4942 100644 --- a/tests/fixtures/analysis/registry-matrix/sha.json +++ b/tests/fixtures/analysis/registry-matrix/sha.json @@ -15,14 +15,6 @@ { "id": "sha#d15102a86f23/ansi_off", "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#e797d848306b/ansi_on", - "reason": "SELECT sha(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/sha1.json b/tests/fixtures/analysis/registry-matrix/sha1.json index 539e7afba..cef68bf63 100644 --- a/tests/fixtures/analysis/registry-matrix/sha1.json +++ b/tests/fixtures/analysis/registry-matrix/sha1.json @@ -15,14 +15,6 @@ { "id": "sha1#186efaceecd5/ansi_off", "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#c4dfb65cb3b0/ansi_on", - "reason": "SELECT sha1(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sha1#c4dfb65cb3b0/ansi_off", - "reason": "SELECT sha1(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/sha2.json b/tests/fixtures/analysis/registry-matrix/sha2.json index 91165cbff..09d346600 100644 --- a/tests/fixtures/analysis/registry-matrix/sha2.json +++ b/tests/fixtures/analysis/registry-matrix/sha2.json @@ -8,14 +8,6 @@ "id": "sha2#028e8e215b71/ansi_off", "reason": "SELECT sha2(INTERVAL '1-2' YEAR TO MONTH, 256) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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#0d551c2bd461/ansi_off", - "reason": "SELECT sha2(map('a', 1), 256) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sha2#5e52fda43a4c/ansi_on", "reason": "SELECT sha2('Spark', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "sha2#9a804177f733/ansi_off", "reason": "SELECT sha2('Spark', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sha2#aad417ead53d/ansi_on", - "reason": "SELECT sha2('Spark', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sha2#aad417ead53d/ansi_off", - "reason": "SELECT sha2('Spark', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sha2#e27329169b2b/ansi_on", "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" diff --git a/tests/fixtures/analysis/registry-matrix/shiftleft.json b/tests/fixtures/analysis/registry-matrix/shiftleft.json index 9a48725b3..92a379129 100644 --- a/tests/fixtures/analysis/registry-matrix/shiftleft.json +++ b/tests/fixtures/analysis/registry-matrix/shiftleft.json @@ -8,14 +8,6 @@ "id": "shiftleft#109b5e440103/ansi_off", "reason": "SELECT shiftleft(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "shiftleft#75289f56a862/ansi_on", - "reason": "SELECT shiftleft(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftleft#75289f56a862/ansi_off", - "reason": "SELECT shiftleft(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "shiftleft#7e69e60b6b3c/ansi_on", "reason": "SELECT shiftleft(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -39,14 +31,6 @@ { "id": "shiftleft#afabf3aa4e4e/ansi_off", "reason": "SELECT shiftleft(2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftleft#be790cf836c8/ansi_on", - "reason": "SELECT shiftleft(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftleft#be790cf836c8/ansi_off", - "reason": "SELECT shiftleft(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/shiftright.json b/tests/fixtures/analysis/registry-matrix/shiftright.json index 0c0e64459..80a615e72 100644 --- a/tests/fixtures/analysis/registry-matrix/shiftright.json +++ b/tests/fixtures/analysis/registry-matrix/shiftright.json @@ -16,22 +16,6 @@ "id": "shiftright#43df86d52cf4/ansi_off", "reason": "SELECT shiftright(4, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "shiftright#5b3114291aea/ansi_on", - "reason": "SELECT shiftright(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftright#5b3114291aea/ansi_off", - "reason": "SELECT shiftright(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftright#7772030a1088/ansi_on", - "reason": "SELECT shiftright(4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftright#7772030a1088/ansi_off", - "reason": "SELECT shiftright(4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "shiftright#9d0da0110d86/ansi_on", "reason": "SELECT shiftright(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json b/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json index cf7fbc34e..d8a53c044 100644 --- a/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json +++ b/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "shiftrightunsigned#5a87b30b960f/ansi_on", - "reason": "SELECT shiftrightunsigned(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftrightunsigned#5a87b30b960f/ansi_off", - "reason": "SELECT shiftrightunsigned(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "shiftrightunsigned#a296dcfd561b/ansi_on", "reason": "SELECT shiftrightunsigned(INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "shiftrightunsigned#a98abd591825/ansi_off", "reason": "SELECT shiftrightunsigned(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "shiftrightunsigned#b48148d54ec4/ansi_on", - "reason": "SELECT shiftrightunsigned(4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftrightunsigned#b48148d54ec4/ansi_off", - "reason": "SELECT shiftrightunsigned(4, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "shiftrightunsigned#e92fea19ed31/ansi_on", "reason": "SELECT shiftrightunsigned(4, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sign.json b/tests/fixtures/analysis/registry-matrix/sign.json index 0722da7a0..e5580d28f 100644 --- a/tests/fixtures/analysis/registry-matrix/sign.json +++ b/tests/fixtures/analysis/registry-matrix/sign.json @@ -24,14 +24,6 @@ "id": "sign#71aec8bd236a/ansi_off", "reason": "SELECT sign(INTERVAL -'100' YEAR) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "sign#94ac29c7be5e/ansi_on", - "reason": "SELECT sign(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sign#94ac29c7be5e/ansi_off", - "reason": "SELECT sign(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sign#b5ebcde7d65f/ansi_on", "reason": "SELECT sign(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/signum.json b/tests/fixtures/analysis/registry-matrix/signum.json index f92fdc005..673310e4a 100644 --- a/tests/fixtures/analysis/registry-matrix/signum.json +++ b/tests/fixtures/analysis/registry-matrix/signum.json @@ -31,14 +31,6 @@ { "id": "signum#854c4eb019e8/ansi_off", "reason": "SELECT signum(CAST(NULL AS interval year)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")" - }, - { - "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#d0d71adb94f9/ansi_off", - "reason": "SELECT signum(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/sin.json b/tests/fixtures/analysis/registry-matrix/sin.json index 9b4e2b91a..390c5a0ca 100644 --- a/tests/fixtures/analysis/registry-matrix/sin.json +++ b/tests/fixtures/analysis/registry-matrix/sin.json @@ -8,14 +8,6 @@ "id": "sin#07aad739ca7b/ansi_off", "reason": "SELECT sin(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sin#6de2eba5fd5b/ansi_on", - "reason": "SELECT sin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, { "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" diff --git a/tests/fixtures/analysis/registry-matrix/sinh.json b/tests/fixtures/analysis/registry-matrix/sinh.json index 2016e4a9b..b1c3c8ef5 100644 --- a/tests/fixtures/analysis/registry-matrix/sinh.json +++ b/tests/fixtures/analysis/registry-matrix/sinh.json @@ -8,14 +8,6 @@ "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" }, - { - "id": "sinh#7f3e399ee823/ansi_on", - "reason": "SELECT sinh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, { "id": "sinh#feb84311c281/ansi_on", "reason": "SELECT sinh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/soundex.json b/tests/fixtures/analysis/registry-matrix/soundex.json index d8b2b551b..809c5b058 100644 --- a/tests/fixtures/analysis/registry-matrix/soundex.json +++ b/tests/fixtures/analysis/registry-matrix/soundex.json @@ -15,14 +15,6 @@ { "id": "soundex#ccd858418689/ansi_off", "reason": "SELECT soundex(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "soundex#d5ca2c3e019c/ansi_on", - "reason": "SELECT soundex(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "soundex#d5ca2c3e019c/ansi_off", - "reason": "SELECT soundex(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/space.json b/tests/fixtures/analysis/registry-matrix/space.json index d92b8b340..2fad0cb7a 100644 --- a/tests/fixtures/analysis/registry-matrix/space.json +++ b/tests/fixtures/analysis/registry-matrix/space.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "space#70281a1865ed/ansi_on", - "reason": "SELECT concat(space(map('a', 1)), '1') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "space#70281a1865ed/ansi_off", - "reason": "SELECT concat(space(map('a', 1)), '1') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "space#d7685f028956/ansi_on", "reason": "SELECT concat(space(INTERVAL '1 02:03:04' DAY TO SECOND), '1') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/split_part.json b/tests/fixtures/analysis/registry-matrix/split_part.json index 241b8bf55..6ce217cde 100644 --- a/tests/fixtures/analysis/registry-matrix/split_part.json +++ b/tests/fixtures/analysis/registry-matrix/split_part.json @@ -16,14 +16,6 @@ "id": "split_part#45999b18c3c3/ansi_off", "reason": "SELECT split_part('11.12.13', INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "split_part#4785dc91b5b6/ansi_on", - "reason": "SELECT split_part('11.12.13', '.', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "split_part#4785dc91b5b6/ansi_off", - "reason": "SELECT split_part('11.12.13', '.', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "split_part#5684a16088e9/ansi_on", "reason": "SELECT split_part('11.12.13', '.', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -40,14 +32,6 @@ "id": "split_part#804bf5201c99/ansi_off", "reason": "SELECT split_part(INTERVAL '1 02:03:04' DAY TO SECOND, '.', 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "split_part#8fa9e60ee191/ansi_on", - "reason": "SELECT split_part(map('a', 1), '.', 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "split_part#8fa9e60ee191/ansi_off", - "reason": "SELECT split_part(map('a', 1), '.', 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "split_part#d917928f192b/ansi_on", "reason": "SELECT split_part('11.12.13', '.', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +40,6 @@ "id": "split_part#d917928f192b/ansi_off", "reason": "SELECT split_part('11.12.13', '.', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "split_part#dd1e4d2ceaea/ansi_on", - "reason": "SELECT split_part('11.12.13', map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "split_part#dd1e4d2ceaea/ansi_off", - "reason": "SELECT split_part('11.12.13', map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "split_part#f852429f985a/ansi_on", "reason": "SELECT split_part('11.12.13', INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/sqrt.json b/tests/fixtures/analysis/registry-matrix/sqrt.json index 42eed0952..a7d976c2c 100644 --- a/tests/fixtures/analysis/registry-matrix/sqrt.json +++ b/tests/fixtures/analysis/registry-matrix/sqrt.json @@ -8,14 +8,6 @@ "id": "sqrt#16036e88e7c1/ansi_off", "reason": "SELECT sqrt(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sqrt#4cf0f8ae607a/ansi_on", - "reason": "SELECT sqrt(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sqrt#4cf0f8ae607a/ansi_off", - "reason": "SELECT sqrt(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sqrt#eec06e7fff26/ansi_on", "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" diff --git a/tests/fixtures/analysis/registry-matrix/startswith.json b/tests/fixtures/analysis/registry-matrix/startswith.json index 5cb7e549a..fe2e9850a 100644 --- a/tests/fixtures/analysis/registry-matrix/startswith.json +++ b/tests/fixtures/analysis/registry-matrix/startswith.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "startswith#122bb4b0fcf8/ansi_on", - "reason": "SELECT startswith(map('a', 1), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "startswith#122bb4b0fcf8/ansi_off", - "reason": "SELECT startswith(map('a', 1), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "startswith#19b35e358339/ansi_on", "reason": "SELECT startswith(INTERVAL '1-2' YEAR TO MONTH, 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -39,14 +31,6 @@ { "id": "startswith#a3323368e4d6/ansi_off", "reason": "SELECT startswith(INTERVAL '1 02:03:04' DAY TO SECOND, 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "startswith#a56ab8af6405/ansi_on", - "reason": "SELECT startswith('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "startswith#a56ab8af6405/ansi_off", - "reason": "SELECT startswith('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/str_to_map.json b/tests/fixtures/analysis/registry-matrix/str_to_map.json new file mode 100644 index 000000000..65431fafa --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/str_to_map.json @@ -0,0 +1,70 @@ +{ + "entries": [ + { + "id": "str_to_map#07a1365a2474/ansi_on", + "reason": "SELECT str_to_map(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#07a1365a2474/ansi_off", + "reason": "SELECT str_to_map(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#1679103bbc98/ansi_on", + "reason": "SELECT str_to_map('a:1,b:2,c:3', INTERVAL '1 02:03:04' DAY TO SECOND, ':') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#1679103bbc98/ansi_off", + "reason": "SELECT str_to_map('a:1,b:2,c:3', INTERVAL '1 02:03:04' DAY TO SECOND, ':') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#2990fe9480e3/ansi_on", + "reason": "SELECT str_to_map('a:1,b:2,c:3', ',', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#2990fe9480e3/ansi_off", + "reason": "SELECT str_to_map('a:1,b:2,c:3', ',', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#374f23833852/ansi_on", + "reason": "SELECT str_to_map(INTERVAL '1-2' YEAR TO MONTH, ',', ':') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#374f23833852/ansi_off", + "reason": "SELECT str_to_map(INTERVAL '1-2' YEAR TO MONTH, ',', ':') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#786c26e75a65/ansi_on", + "reason": "SELECT str_to_map('a:1,b:2,c:3', ',', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#786c26e75a65/ansi_off", + "reason": "SELECT str_to_map('a:1,b:2,c:3', ',', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#7e44d14b9958/ansi_on", + "reason": "SELECT str_to_map('a:1,b:2,c:3', INTERVAL '1-2' YEAR TO MONTH, ':') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#7e44d14b9958/ansi_off", + "reason": "SELECT str_to_map('a:1,b:2,c:3', INTERVAL '1-2' YEAR TO MONTH, ':') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#a1b187e22590/ansi_on", + "reason": "SELECT str_to_map(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#a1b187e22590/ansi_off", + "reason": "SELECT str_to_map(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#e70b2a346402/ansi_on", + "reason": "SELECT str_to_map(INTERVAL '1 02:03:04' DAY TO SECOND, ',', ':') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#e70b2a346402/ansi_off", + "reason": "SELECT str_to_map(INTERVAL '1 02:03:04' DAY TO SECOND, ',', ':') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + } + ], + "format_version": 1, + "function": "str_to_map" +} diff --git a/tests/fixtures/analysis/registry-matrix/struct.json b/tests/fixtures/analysis/registry-matrix/struct.json index 9d0d0129f..8d7bbf20b 100644 --- a/tests/fixtures/analysis/registry-matrix/struct.json +++ b/tests/fixtures/analysis/registry-matrix/struct.json @@ -8,14 +8,6 @@ "id": "struct#0fc70328ef5f/ansi_off", "reason": "SELECT struct(1, 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "struct#3de026bd0cd4/ansi_on", - "reason": "SELECT struct(1, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "struct#3de026bd0cd4/ansi_off", - "reason": "SELECT struct(1, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, { "id": "struct#3e4211a87a87/ansi_on", "reason": "SELECT struct(INTERVAL '1 02:03:04' DAY TO SECOND, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -24,22 +16,6 @@ "id": "struct#3e4211a87a87/ansi_off", "reason": "SELECT struct(INTERVAL '1 02:03:04' DAY TO SECOND, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "struct#49208d6410c1/ansi_on", - "reason": "SELECT struct(map('a', 1), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "struct#49208d6410c1/ansi_off", - "reason": "SELECT struct(map('a', 1), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "struct#5145e16a16a9/ansi_on", - "reason": "SELECT struct(1, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "struct#5145e16a16a9/ansi_off", - "reason": "SELECT struct(1, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, { "id": "struct#5f8c80f88ab9/ansi_on", "reason": "SELECT struct(1, INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/substr.json b/tests/fixtures/analysis/registry-matrix/substr.json index d486b39ab..ceeb9a657 100644 --- a/tests/fixtures/analysis/registry-matrix/substr.json +++ b/tests/fixtures/analysis/registry-matrix/substr.json @@ -24,14 +24,6 @@ "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#33fcc8cec89e/ansi_on", - "reason": "SELECT substr(map('a', 1), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substr#33fcc8cec89e/ansi_off", - "reason": "SELECT substr(map('a', 1), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substr#4f609ceaa310/ansi_on", "reason": "SELECT substr('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -40,22 +32,6 @@ "id": "substr#4f609ceaa310/ansi_off", "reason": "SELECT substr('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substr#723f8b45fc39/ansi_on", - "reason": "SELECT substr('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, - { - "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#738183a8ca56/ansi_off", - "reason": "SELECT substr(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substr#88aca1035a99/ansi_on", "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" @@ -88,22 +64,6 @@ "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" }, - { - "id": "substr#a02122420647/ansi_on", - "reason": "SELECT substr('Spark SQL', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substr#a02122420647/ansi_off", - "reason": "SELECT substr('Spark SQL', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substr#db430fd33e45/ansi_on", - "reason": "SELECT substr('Spark SQL', map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substr#db430fd33e45/ansi_off", - "reason": "SELECT substr('Spark SQL', map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substr#f4b691e3b8ea/ansi_on", "reason": "SELECT substr(INTERVAL '1-2' YEAR TO MONTH, 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/substring.json b/tests/fixtures/analysis/registry-matrix/substring.json index ac12423bc..da4a66cba 100644 --- a/tests/fixtures/analysis/registry-matrix/substring.json +++ b/tests/fixtures/analysis/registry-matrix/substring.json @@ -32,22 +32,6 @@ "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" }, - { - "id": "substring#37da65e3c091/ansi_on", - "reason": "SELECT substring('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring#37da65e3c091/ansi_off", - "reason": "SELECT substring('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring#3abd4df7e954/ansi_on", - "reason": "SELECT substring(map('a', 1), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring#3abd4df7e954/ansi_off", - "reason": "SELECT substring(map('a', 1), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substring#3f2624e3879f/ansi_on", "reason": "SELECT substring('Spark SQL', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +48,6 @@ "id": "substring#525e241ea7f0/ansi_off", "reason": "SELECT substring(INTERVAL '1-2' YEAR TO MONTH, 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "substring#6372499e9a5a/ansi_on", - "reason": "SELECT substring(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map 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" - }, { "id": "substring#8b42b0b920a8/ansi_on", "reason": "SELECT substring('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -96,14 +72,6 @@ "id": "substring#9715e4291ca1/ansi_off", "reason": "SELECT substring(INTERVAL '1 02:03:04' DAY TO SECOND, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "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#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" - }, { "id": "substring#cecac4e8ad77/ansi_on", "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" @@ -111,14 +79,6 @@ { "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" - }, - { - "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#d0a9e5313045/ansi_off", - "reason": "SELECT substring('Spark SQL', map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/substring_index.json b/tests/fixtures/analysis/registry-matrix/substring_index.json index 3ccafb31d..70fcd16bc 100644 --- a/tests/fixtures/analysis/registry-matrix/substring_index.json +++ b/tests/fixtures/analysis/registry-matrix/substring_index.json @@ -8,14 +8,6 @@ "id": "substring_index#20de8a49e085/ansi_off", "reason": "SELECT substring_index('www.apache.org', INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "substring_index#3891f2bca04a/ansi_on", - "reason": "SELECT substring_index('www.apache.org', '.', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring_index#3891f2bca04a/ansi_off", - "reason": "SELECT substring_index('www.apache.org', '.', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substring_index#52f4898847e9/ansi_on", "reason": "SELECT substring_index('www.apache.org', '.', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -24,14 +16,6 @@ "id": "substring_index#52f4898847e9/ansi_off", "reason": "SELECT substring_index('www.apache.org', '.', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substring_index#8dcf07f370c5/ansi_on", - "reason": "SELECT substring_index(map('a', 1), '.', 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring_index#8dcf07f370c5/ansi_off", - "reason": "SELECT substring_index(map('a', 1), '.', 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substring_index#ab14b0f764a7/ansi_on", "reason": "SELECT substring_index(INTERVAL '1 02:03:04' DAY TO SECOND, '.', 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -48,14 +32,6 @@ "id": "substring_index#c76bb482b4cd/ansi_off", "reason": "SELECT substring_index('www.apache.org', '.', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substring_index#cab5bdcf4852/ansi_on", - "reason": "SELECT substring_index('www.apache.org', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring_index#cab5bdcf4852/ansi_off", - "reason": "SELECT substring_index('www.apache.org', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substring_index#d5063ca1edaf/ansi_on", "reason": "SELECT substring_index('www.apache.org', INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/tan.json b/tests/fixtures/analysis/registry-matrix/tan.json index fc2f00d04..d94ba0683 100644 --- a/tests/fixtures/analysis/registry-matrix/tan.json +++ b/tests/fixtures/analysis/registry-matrix/tan.json @@ -8,14 +8,6 @@ "id": "tan#55cf6a79e785/ansi_off", "reason": "SELECT tan(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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#a3734f7996ca/ansi_off", - "reason": "SELECT tan(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "tan#eef3973d8de1/ansi_on", "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" diff --git a/tests/fixtures/analysis/registry-matrix/tanh.json b/tests/fixtures/analysis/registry-matrix/tanh.json index caab3a027..26618187f 100644 --- a/tests/fixtures/analysis/registry-matrix/tanh.json +++ b/tests/fixtures/analysis/registry-matrix/tanh.json @@ -1,13 +1,5 @@ { "entries": [ - { - "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#054342254ba1/ansi_off", - "reason": "SELECT tanh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "tanh#bc60aa3cc8fe/ansi_on", "reason": "SELECT tanh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/to_binary.json b/tests/fixtures/analysis/registry-matrix/to_binary.json index 594b1175b..061e08742 100644 --- a/tests/fixtures/analysis/registry-matrix/to_binary.json +++ b/tests/fixtures/analysis/registry-matrix/to_binary.json @@ -18,19 +18,11 @@ }, { "id": "to_binary#29d90641d1a0/ansi_on", - "reason": "SELECT to_binary('abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE" + "reason": "SELECT to_binary('abc', map('a', 1)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE" }, { "id": "to_binary#29d90641d1a0/ansi_off", - "reason": "SELECT to_binary('abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE" - }, - { - "id": "to_binary#324e66491a2a/ansi_on", - "reason": "SELECT to_binary(map('a', 1), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_binary#324e66491a2a/ansi_off", - "reason": "SELECT to_binary(map('a', 1), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT to_binary('abc', map('a', 1)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE" }, { "id": "to_binary#35b4d980b59d/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/to_char.json b/tests/fixtures/analysis/registry-matrix/to_char.json index c509d1ecb..73803a303 100644 --- a/tests/fixtures/analysis/registry-matrix/to_char.json +++ b/tests/fixtures/analysis/registry-matrix/to_char.json @@ -16,22 +16,6 @@ "id": "to_char#7c77983e5a32/ansi_off", "reason": "SELECT to_char(INTERVAL '1 02:03:04' DAY TO SECOND, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "to_char#944ae2d02990/ansi_on", - "reason": "SELECT to_char(454, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_char#944ae2d02990/ansi_off", - "reason": "SELECT to_char(454, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_char#aac5b4c801e4/ansi_on", - "reason": "SELECT to_char(map('a', 1), '999') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_char#aac5b4c801e4/ansi_off", - "reason": "SELECT to_char(map('a', 1), '999') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_char#c40379bd4176/ansi_on", "reason": "SELECT to_char(INTERVAL '1-2' YEAR TO MONTH, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/to_number.json b/tests/fixtures/analysis/registry-matrix/to_number.json index 11f27407e..c2d7b45cc 100644 --- a/tests/fixtures/analysis/registry-matrix/to_number.json +++ b/tests/fixtures/analysis/registry-matrix/to_number.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "to_number#09301160cd3a/ansi_on", - "reason": "SELECT to_number(map('a', 1), '999') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_number#09301160cd3a/ansi_off", - "reason": "SELECT to_number(map('a', 1), '999') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_number#2ac9fb75cd2c/ansi_on", "reason": "SELECT to_number(INTERVAL '1-2' YEAR TO MONTH, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -40,14 +32,6 @@ "id": "to_number#8e822c2c1477/ansi_off", "reason": "SELECT to_number(INTERVAL '1 02:03:04' DAY TO SECOND, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "to_number#9f6b24a08df4/ansi_on", - "reason": "SELECT to_number('454', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_number#9f6b24a08df4/ansi_off", - "reason": "SELECT to_number('454', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_number#a9a4941ee7c0/ansi_on", "reason": "SELECT to_number('454', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has INVALID_FORMAT.UNEXPECTED_TOKEN" diff --git a/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json b/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json index dfb1ffe25..a78fdf6ae 100644 --- a/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json +++ b/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json @@ -16,14 +16,6 @@ "id": "to_utc_timestamp#18b601a625bc/ansi_off", "reason": "SELECT to_utc_timestamp(INTERVAL '1 02:03:04' DAY TO SECOND, 'Asia/Seoul') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "to_utc_timestamp#1e2ecc93ecec/ansi_on", - "reason": "SELECT to_utc_timestamp('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_utc_timestamp#1e2ecc93ecec/ansi_off", - "reason": "SELECT to_utc_timestamp('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_utc_timestamp#4007b97e1f30/ansi_on", "reason": "SELECT to_utc_timestamp('2016-08-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -32,14 +24,6 @@ "id": "to_utc_timestamp#4007b97e1f30/ansi_off", "reason": "SELECT to_utc_timestamp('2016-08-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "to_utc_timestamp#9ec1404ab832/ansi_on", - "reason": "SELECT to_utc_timestamp(map('a', 1), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_utc_timestamp#9ec1404ab832/ansi_off", - "reason": "SELECT to_utc_timestamp(map('a', 1), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_utc_timestamp#fd6dc008f49b/ansi_on", "reason": "SELECT to_utc_timestamp('2016-08-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/to_varchar.json b/tests/fixtures/analysis/registry-matrix/to_varchar.json index 1fc90d48f..930dbb07e 100644 --- a/tests/fixtures/analysis/registry-matrix/to_varchar.json +++ b/tests/fixtures/analysis/registry-matrix/to_varchar.json @@ -16,14 +16,6 @@ "id": "to_varchar#4632c0405904/ansi_off", "reason": "SELECT to_varchar(454, TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has INVALID_FORMAT.UNEXPECTED_TOKEN" }, - { - "id": "to_varchar#55538a187bc6/ansi_on", - "reason": "SELECT to_varchar(map('a', 1), '999') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_varchar#55538a187bc6/ansi_off", - "reason": "SELECT to_varchar(map('a', 1), '999') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_varchar#563016f396de/ansi_on", "reason": "SELECT to_varchar(INTERVAL '1 02:03:04' DAY TO SECOND, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,6 @@ "id": "to_varchar#9f23b08b45e0/ansi_off", "reason": "SELECT to_varchar(INTERVAL '1-2' YEAR TO MONTH, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "to_varchar#ebf434f037b3/ansi_on", - "reason": "SELECT to_varchar(454, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_varchar#ebf434f037b3/ansi_off", - "reason": "SELECT to_varchar(454, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_varchar#f1b538d4cc40/ansi_on", "reason": "SELECT to_varchar(454, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_TOKEN" diff --git a/tests/fixtures/analysis/registry-matrix/transform.json b/tests/fixtures/analysis/registry-matrix/transform.json index e1b08097c..5932b42f5 100644 --- a/tests/fixtures/analysis/registry-matrix/transform.json +++ b/tests/fixtures/analysis/registry-matrix/transform.json @@ -15,14 +15,6 @@ { "id": "transform#5724275e0d67/ansi_off", "reason": "SELECT transform(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x + 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "transform#5819dd452d8e/ansi_on", - "reason": "SELECT transform(map('a', 1), x -> x + 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "transform#5819dd452d8e/ansi_off", - "reason": "SELECT transform(map('a', 1), x -> x + 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/translate.json b/tests/fixtures/analysis/registry-matrix/translate.json index 28807cda9..d02fa867f 100644 --- a/tests/fixtures/analysis/registry-matrix/translate.json +++ b/tests/fixtures/analysis/registry-matrix/translate.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "translate#3fe19d6d2609/ansi_on", - "reason": "SELECT translate(map('a', 1), 'abc', '123') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "translate#3fe19d6d2609/ansi_off", - "reason": "SELECT translate(map('a', 1), 'abc', '123') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "translate#4fc6835d5253/ansi_on", "reason": "SELECT translate('AaBbCc', 'abc', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -16,14 +8,6 @@ "id": "translate#4fc6835d5253/ansi_off", "reason": "SELECT translate('AaBbCc', 'abc', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "translate#6a0577c13182/ansi_on", - "reason": "SELECT translate('AaBbCc', 'abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "translate#6a0577c13182/ansi_off", - "reason": "SELECT translate('AaBbCc', 'abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "translate#6b471fcf6248/ansi_on", "reason": "SELECT translate('AaBbCc', 'abc', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -32,14 +16,6 @@ "id": "translate#6b471fcf6248/ansi_off", "reason": "SELECT translate('AaBbCc', 'abc', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "translate#7ef5ac648b85/ansi_on", - "reason": "SELECT translate('AaBbCc', map('a', 1), '123') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "translate#7ef5ac648b85/ansi_off", - "reason": "SELECT translate('AaBbCc', map('a', 1), '123') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "translate#8a5e59a300f4/ansi_on", "reason": "SELECT translate(INTERVAL '1-2' YEAR TO MONTH, 'abc', '123') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/trim.json b/tests/fixtures/analysis/registry-matrix/trim.json index 044f75c29..15c27cbde 100644 --- a/tests/fixtures/analysis/registry-matrix/trim.json +++ b/tests/fixtures/analysis/registry-matrix/trim.json @@ -15,14 +15,6 @@ { "id": "trim#eb0fa3d83d97/ansi_off", "reason": "SELECT trim(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "trim#ff7e17fd365a/ansi_on", - "reason": "SELECT trim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "trim#ff7e17fd365a/ansi_off", - "reason": "SELECT trim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/trunc.json b/tests/fixtures/analysis/registry-matrix/trunc.json index 3eb679956..eb1a87970 100644 --- a/tests/fixtures/analysis/registry-matrix/trunc.json +++ b/tests/fixtures/analysis/registry-matrix/trunc.json @@ -8,14 +8,6 @@ "id": "trunc#1da48f62f9ff/ansi_off", "reason": "SELECT trunc('2019-08-04', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "trunc#3f6bf3a87eef/ansi_on", - "reason": "SELECT trunc(map('a', 1), 'week') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "trunc#3f6bf3a87eef/ansi_off", - "reason": "SELECT trunc(map('a', 1), 'week') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "trunc#a25de6ca5aa9/ansi_on", "reason": "SELECT trunc(INTERVAL '1-2' YEAR TO MONTH, 'week') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -24,14 +16,6 @@ "id": "trunc#a25de6ca5aa9/ansi_off", "reason": "SELECT trunc(INTERVAL '1-2' YEAR TO MONTH, 'week') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "trunc#d424704624cc/ansi_on", - "reason": "SELECT trunc('2019-08-04', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "trunc#d424704624cc/ansi_off", - "reason": "SELECT trunc('2019-08-04', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "trunc#daca01bba216/ansi_on", "reason": "SELECT trunc(INTERVAL '1 02:03:04' DAY TO SECOND, 'week') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/try_add.json b/tests/fixtures/analysis/registry-matrix/try_add.json index 07461a0a6..053ea4886 100644 --- a/tests/fixtures/analysis/registry-matrix/try_add.json +++ b/tests/fixtures/analysis/registry-matrix/try_add.json @@ -36,14 +36,6 @@ "id": "try_add#20d5ec1fdf9e/ansi_off", "reason": "SELECT try_add('abc', 2) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "id": "try_add#2ee9c3a939bc/ansi_on", - "reason": "SELECT try_add(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_add#2ee9c3a939bc/ansi_off", - "reason": "SELECT try_add(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map 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) | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" @@ -140,14 +132,6 @@ "id": "try_add#80670b49f5fe/ansi_off", "reason": "SELECT try_add(date'2021-01-01', CAST(NULL AS interval year)) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")" }, - { - "id": "try_add#97c240c3d841/ansi_on", - "reason": "SELECT try_add(1, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_add#97c240c3d841/ansi_off", - "reason": "SELECT try_add(1, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_add#9e05d939ec33/ansi_on", "reason": "SELECT try_add(TIMESTAMP'2024-03-10 02:30:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/try_divide.json b/tests/fixtures/analysis/registry-matrix/try_divide.json index 43658f719..8d7ca1189 100644 --- a/tests/fixtures/analysis/registry-matrix/try_divide.json +++ b/tests/fixtures/analysis/registry-matrix/try_divide.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "try_divide#112274802913/ansi_on", - "reason": "SELECT try_divide(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_divide#112274802913/ansi_off", - "reason": "SELECT try_divide(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_divide#438928ec5060/ansi_on", "reason": "SELECT try_divide(INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -44,14 +36,6 @@ "id": "try_divide#9dd353d73dc5/ansi_off", "reason": "SELECT try_divide(3, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "try_divide#9f14e58b2a21/ansi_on", - "reason": "SELECT try_divide(3, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_divide#9f14e58b2a21/ansi_off", - "reason": "SELECT try_divide(3, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_divide#a76d0c6954f9/ansi_on", "reason": "SELECT try_divide(interval 2 month, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/try_mod.json b/tests/fixtures/analysis/registry-matrix/try_mod.json index 900fc32ae..a29e35044 100644 --- a/tests/fixtures/analysis/registry-matrix/try_mod.json +++ b/tests/fixtures/analysis/registry-matrix/try_mod.json @@ -8,14 +8,6 @@ "id": "try_mod#02ec6588b5da/ansi_off", "reason": "SELECT try_mod(INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "try_mod#0ffbfe056c84/ansi_on", - "reason": "SELECT try_mod(3, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_mod#0ffbfe056c84/ansi_off", - "reason": "SELECT try_mod(3, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_mod#132344b1189f/ansi_on", "reason": "SELECT try_mod(3, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" @@ -36,14 +28,6 @@ "id": "try_mod#3c9ef04734c1/ansi_off", "reason": "SELECT try_mod(3, '1') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "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#61c91dfb3758/ansi_off", - "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#717ca6f04521/ansi_off", "reason": "SELECT try_mod(3, 'abc') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" diff --git a/tests/fixtures/analysis/registry-matrix/try_multiply.json b/tests/fixtures/analysis/registry-matrix/try_multiply.json index 47848d75f..e2e03469d 100644 --- a/tests/fixtures/analysis/registry-matrix/try_multiply.json +++ b/tests/fixtures/analysis/registry-matrix/try_multiply.json @@ -24,22 +24,6 @@ "id": "try_multiply#420e775113c8/ansi_off", "reason": "SELECT try_multiply(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "try_multiply#44bf4c417400/ansi_on", - "reason": "SELECT try_multiply(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_multiply#44bf4c417400/ansi_off", - "reason": "SELECT try_multiply(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "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#4ad5e706ba92/ansi_off", - "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#602e46974789/ansi_on", "reason": "SELECT try_multiply(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/try_parse_url.json b/tests/fixtures/analysis/registry-matrix/try_parse_url.json index e3a7ea03b..e766382bb 100644 --- a/tests/fixtures/analysis/registry-matrix/try_parse_url.json +++ b/tests/fixtures/analysis/registry-matrix/try_parse_url.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "try_parse_url#0e12119c68fa/ansi_on", - "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', 'QUERY', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_parse_url#0e12119c68fa/ansi_off", - "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', 'QUERY', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_parse_url#1035b2edbf0f/ansi_on", "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -24,14 +16,6 @@ "id": "try_parse_url#15d4338a64c9/ansi_off", "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', 'QUERY', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "try_parse_url#1ccc05c6b568/ansi_on", - "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', map('a', 1), 'query') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_parse_url#1ccc05c6b568/ansi_off", - "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', map('a', 1), 'query') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_parse_url#1ef5ed023628/ansi_on", "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', INTERVAL '1 02:03:04' DAY TO SECOND, 'query') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +32,6 @@ "id": "try_parse_url#2c278d2df488/ansi_off", "reason": "SELECT try_parse_url(INTERVAL '1 02:03:04' DAY TO SECOND, 'QUERY', 'query') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "try_parse_url#37c0beb26184/ansi_on", - "reason": "SELECT try_parse_url(map('a', 1), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_parse_url#37c0beb26184/ansi_off", - "reason": "SELECT try_parse_url(map('a', 1), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_parse_url#478712dca34b/ansi_on", "reason": "SELECT try_parse_url(INTERVAL '1 02:03:04' DAY TO SECOND, 'HOST') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -72,14 +48,6 @@ "id": "try_parse_url#48d9e4f27891/ansi_off", "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "try_parse_url#6cd107179b5a/ansi_on", - "reason": "SELECT try_parse_url(map('a', 1), 'HOST') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_parse_url#6cd107179b5a/ansi_off", - "reason": "SELECT try_parse_url(map('a', 1), 'HOST') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_parse_url#99a7f2da2ece/ansi_on", "reason": "SELECT try_parse_url(INTERVAL '1-2' YEAR TO MONTH, 'HOST') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -88,14 +56,6 @@ "id": "try_parse_url#99a7f2da2ece/ansi_off", "reason": "SELECT try_parse_url(INTERVAL '1-2' YEAR TO MONTH, 'HOST') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "try_parse_url#adc8c07a0fc6/ansi_on", - "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_parse_url#adc8c07a0fc6/ansi_off", - "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_parse_url#b3be60b5bab4/ansi_on", "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', 'QUERY', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/try_subtract.json b/tests/fixtures/analysis/registry-matrix/try_subtract.json index 10e33cd40..2a753d534 100644 --- a/tests/fixtures/analysis/registry-matrix/try_subtract.json +++ b/tests/fixtures/analysis/registry-matrix/try_subtract.json @@ -196,14 +196,6 @@ "id": "try_subtract#d6e583e2358c/ansi_off", "reason": "SELECT try_subtract(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "try_subtract#df292aab8ace/ansi_on", - "reason": "SELECT try_subtract(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_subtract#df292aab8ace/ansi_off", - "reason": "SELECT try_subtract(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_subtract#e73b9f9913d5/ansi_off", "reason": "SELECT try_subtract('1', 1) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" @@ -223,14 +215,6 @@ { "id": "try_subtract#f6e4926b7d7b/ansi_off", "reason": "SELECT try_subtract(CAST(NULL AS timestamp), interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "try_subtract#fca7663b148c/ansi_on", - "reason": "SELECT try_subtract(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_subtract#fca7663b148c/ansi_off", - "reason": "SELECT try_subtract(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/try_to_binary.json b/tests/fixtures/analysis/registry-matrix/try_to_binary.json index 4b630a479..3ac178be6 100644 --- a/tests/fixtures/analysis/registry-matrix/try_to_binary.json +++ b/tests/fixtures/analysis/registry-matrix/try_to_binary.json @@ -50,11 +50,11 @@ }, { "id": "try_to_binary#31d56249332a/ansi_on", - "reason": "SELECT try_to_binary('abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE" + "reason": "SELECT try_to_binary('abc', map('a', 1)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE" }, { "id": "try_to_binary#31d56249332a/ansi_off", - "reason": "SELECT try_to_binary('abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE" + "reason": "SELECT try_to_binary('abc', map('a', 1)) | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has DATATYPE_MISMATCH.INVALID_ARG_VALUE" }, { "id": "try_to_binary#3ecc05846dbe/ansi_on", @@ -64,14 +64,6 @@ "id": "try_to_binary#3ecc05846dbe/ansi_off", "reason": "SELECT try_to_binary('abc', X'01') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT" }, - { - "id": "try_to_binary#658c0bd3fdf2/ansi_on", - "reason": "SELECT try_to_binary(map('a', 1), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_to_binary#658c0bd3fdf2/ansi_off", - "reason": "SELECT try_to_binary(map('a', 1), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_to_binary#7181d729db72/ansi_on", "reason": "SELECT try_to_binary('abc', 1.5D) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT" diff --git a/tests/fixtures/analysis/registry-matrix/try_to_number.json b/tests/fixtures/analysis/registry-matrix/try_to_number.json index 426f79807..ace977148 100644 --- a/tests/fixtures/analysis/registry-matrix/try_to_number.json +++ b/tests/fixtures/analysis/registry-matrix/try_to_number.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "try_to_number#214e9d4c0710/ansi_on", - "reason": "SELECT try_to_number('454', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_to_number#214e9d4c0710/ansi_off", - "reason": "SELECT try_to_number('454', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_to_number#3536c73e6919/ansi_on", "reason": "SELECT try_to_number('454', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_TOKEN" @@ -24,14 +16,6 @@ "id": "try_to_number#37653a0a3375/ansi_off", "reason": "SELECT try_to_number(INTERVAL '1-2' YEAR TO MONTH, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "try_to_number#45bb6eb12996/ansi_on", - "reason": "SELECT try_to_number(map('a', 1), '999') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_to_number#45bb6eb12996/ansi_off", - "reason": "SELECT try_to_number(map('a', 1), '999') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_to_number#77409df43665/ansi_on", "reason": "SELECT try_to_number('454', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has INVALID_FORMAT.UNEXPECTED_TOKEN" diff --git a/tests/fixtures/analysis/registry-matrix/try_url_decode.json b/tests/fixtures/analysis/registry-matrix/try_url_decode.json index 8b12e7cf0..dade376a3 100644 --- a/tests/fixtures/analysis/registry-matrix/try_url_decode.json +++ b/tests/fixtures/analysis/registry-matrix/try_url_decode.json @@ -15,14 +15,6 @@ { "id": "try_url_decode#781e0c1724f2/ansi_off", "reason": "SELECT try_url_decode(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "try_url_decode#9bb611f50c51/ansi_on", - "reason": "SELECT try_url_decode(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_url_decode#9bb611f50c51/ansi_off", - "reason": "SELECT try_url_decode(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/try_validate_utf8.json b/tests/fixtures/analysis/registry-matrix/try_validate_utf8.json index 15936a607..c5e2891d4 100644 --- a/tests/fixtures/analysis/registry-matrix/try_validate_utf8.json +++ b/tests/fixtures/analysis/registry-matrix/try_validate_utf8.json @@ -8,14 +8,6 @@ "id": "try_validate_utf8#2e85e9b22499/ansi_off", "reason": "SELECT try_validate_utf8(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "try_validate_utf8#b4189dbe9026/ansi_on", - "reason": "SELECT try_validate_utf8(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_validate_utf8#b4189dbe9026/ansi_off", - "reason": "SELECT try_validate_utf8(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_validate_utf8#eeb67f464482/ansi_on", "reason": "SELECT try_validate_utf8(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/typeof.json b/tests/fixtures/analysis/registry-matrix/typeof.json index fa1942275..54411a18e 100644 --- a/tests/fixtures/analysis/registry-matrix/typeof.json +++ b/tests/fixtures/analysis/registry-matrix/typeof.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "typeof#737efe3cca2b/ansi_on", - "reason": "SELECT typeof(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "id": "typeof#737efe3cca2b/ansi_off", - "reason": "SELECT typeof(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, { "id": "typeof#85119c3e6111/ansi_on", "reason": "SELECT typeof(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/ucase.json b/tests/fixtures/analysis/registry-matrix/ucase.json index 93863e991..a586908d0 100644 --- a/tests/fixtures/analysis/registry-matrix/ucase.json +++ b/tests/fixtures/analysis/registry-matrix/ucase.json @@ -8,14 +8,6 @@ "id": "ucase#05ac574f466d/ansi_off", "reason": "SELECT ucase(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "ucase#9de2d667346e/ansi_on", - "reason": "SELECT ucase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ucase#9de2d667346e/ansi_off", - "reason": "SELECT ucase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ucase#eddc7fabde57/ansi_on", "reason": "SELECT ucase(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/unbase64.json b/tests/fixtures/analysis/registry-matrix/unbase64.json index 7294d1470..7f4c9e6ef 100644 --- a/tests/fixtures/analysis/registry-matrix/unbase64.json +++ b/tests/fixtures/analysis/registry-matrix/unbase64.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "unbase64#132203927003/ansi_on", - "reason": "SELECT unbase64(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "unbase64#132203927003/ansi_off", - "reason": "SELECT unbase64(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "unbase64#458f1476f09a/ansi_on", "reason": "SELECT unbase64(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/unhex.json b/tests/fixtures/analysis/registry-matrix/unhex.json index 5c8e7a89c..a13cf7d76 100644 --- a/tests/fixtures/analysis/registry-matrix/unhex.json +++ b/tests/fixtures/analysis/registry-matrix/unhex.json @@ -8,14 +8,6 @@ "id": "unhex#30f69b1f28b8/ansi_off", "reason": "SELECT decode(unhex(INTERVAL '1-2' YEAR TO MONTH), 'UTF-8') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "unhex#3339f0365582/ansi_on", - "reason": "SELECT decode(unhex(map('a', 1)), 'UTF-8') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "unhex#3339f0365582/ansi_off", - "reason": "SELECT decode(unhex(map('a', 1)), 'UTF-8') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "unhex#4fe2346478a2/ansi_on", "reason": "SELECT decode(unhex(INTERVAL '1 02:03:04' DAY TO SECOND), 'UTF-8') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/uniform.json b/tests/fixtures/analysis/registry-matrix/uniform.json index 900704b81..d5bba28dd 100644 --- a/tests/fixtures/analysis/registry-matrix/uniform.json +++ b/tests/fixtures/analysis/registry-matrix/uniform.json @@ -24,14 +24,6 @@ "id": "uniform#310b01a5b4ae/ansi_off", "reason": "SELECT uniform(10, INTERVAL '1-2' YEAR TO MONTH, 0) > 0 AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "uniform#3fd714d3fbcf/ansi_on", - "reason": "SELECT uniform(10, map('a', 1), 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "uniform#3fd714d3fbcf/ansi_off", - "reason": "SELECT uniform(10, map('a', 1), 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "uniform#454025458e8a/ansi_on", "reason": "SELECT uniform(10, 20, NULL) > 0 AS result | boolean where Spark has boolean not null" @@ -48,14 +40,6 @@ "id": "uniform#5656d353ced6/ansi_off", "reason": "SELECT uniform(INTERVAL '1-2' YEAR TO MONTH, 20, 0) > 0 AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "uniform#681f70cb51f1/ansi_on", - "reason": "SELECT uniform(map('a', 1), 20, 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "uniform#681f70cb51f1/ansi_off", - "reason": "SELECT uniform(map('a', 1), 20, 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "uniform#6afd046a5774/ansi_on", "reason": "SELECT uniform(10, 20, INTERVAL '1-2' YEAR TO MONTH) > 0 AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -96,14 +80,6 @@ "id": "uniform#ab6b99e0333b/ansi_off", "reason": "SELECT uniform(10, NULL, 0) > 0 AS result | boolean where Spark has boolean not null" }, - { - "id": "uniform#d54a4a610339/ansi_on", - "reason": "SELECT uniform(10, 20, map('a', 1)) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "uniform#d54a4a610339/ansi_off", - "reason": "SELECT uniform(10, 20, map('a', 1)) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "uniform#d942efa11da8/ansi_on", "reason": "SELECT uniform(CAST(1.5 AS DECIMAL(38,18)), 20, 0) > 0 AS result | boolean not null where Spark has boolean" diff --git a/tests/fixtures/analysis/registry-matrix/unix_date.json b/tests/fixtures/analysis/registry-matrix/unix_date.json index 9b8b79c3c..7dc942503 100644 --- a/tests/fixtures/analysis/registry-matrix/unix_date.json +++ b/tests/fixtures/analysis/registry-matrix/unix_date.json @@ -23,14 +23,6 @@ { "id": "unix_date#1e4d788e1647/ansi_off", "reason": "SELECT unix_date(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "unix_date#da1a0a925766/ansi_on", - "reason": "SELECT unix_date(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "unix_date#da1a0a925766/ansi_off", - "reason": "SELECT unix_date(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/upper.json b/tests/fixtures/analysis/registry-matrix/upper.json index 61806e974..d5a7da26e 100644 --- a/tests/fixtures/analysis/registry-matrix/upper.json +++ b/tests/fixtures/analysis/registry-matrix/upper.json @@ -8,14 +8,6 @@ "id": "upper#22f819e17e9b/ansi_off", "reason": "SELECT upper(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "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#753d2b0105f9/ansi_off", - "reason": "SELECT upper(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "upper#a8ece98a87b6/ansi_on", "reason": "SELECT upper(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/url_decode.json b/tests/fixtures/analysis/registry-matrix/url_decode.json index 4975c3868..e9dacc35b 100644 --- a/tests/fixtures/analysis/registry-matrix/url_decode.json +++ b/tests/fixtures/analysis/registry-matrix/url_decode.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "url_decode#397346daef3a/ansi_on", - "reason": "SELECT url_decode(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "url_decode#397346daef3a/ansi_off", - "reason": "SELECT url_decode(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "url_decode#4f5db2bf56bc/ansi_on", "reason": "SELECT url_decode(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/url_encode.json b/tests/fixtures/analysis/registry-matrix/url_encode.json index 52c70fb91..dc60e8106 100644 --- a/tests/fixtures/analysis/registry-matrix/url_encode.json +++ b/tests/fixtures/analysis/registry-matrix/url_encode.json @@ -8,14 +8,6 @@ "id": "url_encode#49305c257f5f/ansi_off", "reason": "SELECT url_encode(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "url_encode#c70459c3420e/ansi_on", - "reason": "SELECT url_encode(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "url_encode#c70459c3420e/ansi_off", - "reason": "SELECT url_encode(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "url_encode#f11b84b1af50/ansi_on", "reason": "SELECT url_encode(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/validate_utf8.json b/tests/fixtures/analysis/registry-matrix/validate_utf8.json index 3c7c93166..dd44aac9c 100644 --- a/tests/fixtures/analysis/registry-matrix/validate_utf8.json +++ b/tests/fixtures/analysis/registry-matrix/validate_utf8.json @@ -15,14 +15,6 @@ { "id": "validate_utf8#c80b7193e8a7/ansi_off", "reason": "SELECT validate_utf8(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "validate_utf8#dc513fc327c3/ansi_on", - "reason": "SELECT validate_utf8(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "validate_utf8#dc513fc327c3/ansi_off", - "reason": "SELECT validate_utf8(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/weekday.json b/tests/fixtures/analysis/registry-matrix/weekday.json index 049038b85..9a74fd0e0 100644 --- a/tests/fixtures/analysis/registry-matrix/weekday.json +++ b/tests/fixtures/analysis/registry-matrix/weekday.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "weekday#1534b8969a15/ansi_on", - "reason": "SELECT weekday(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "weekday#1534b8969a15/ansi_off", - "reason": "SELECT weekday(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "weekday#a8e54d4f1e7a/ansi_on", "reason": "SELECT weekday(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/weekofyear.json b/tests/fixtures/analysis/registry-matrix/weekofyear.json index dc8706c3c..d751a3aaa 100644 --- a/tests/fixtures/analysis/registry-matrix/weekofyear.json +++ b/tests/fixtures/analysis/registry-matrix/weekofyear.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "weekofyear#53358fefc260/ansi_on", - "reason": "SELECT weekofyear(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "weekofyear#53358fefc260/ansi_off", - "reason": "SELECT weekofyear(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "weekofyear#6a78d439768a/ansi_on", "reason": "SELECT weekofyear(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/xxhash64.json b/tests/fixtures/analysis/registry-matrix/xxhash64.json index 9ee343e8c..9ff4d8998 100644 --- a/tests/fixtures/analysis/registry-matrix/xxhash64.json +++ b/tests/fixtures/analysis/registry-matrix/xxhash64.json @@ -2,19 +2,19 @@ "entries": [ { "id": "xxhash64#27bf617616cb/ansi_on", - "reason": "SELECT xxhash64('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT xxhash64('Spark', map('a', 1), 2) | resolves to bigint where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "xxhash64#27bf617616cb/ansi_off", - "reason": "SELECT xxhash64('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT xxhash64('Spark', map('a', 1), 2) | resolves to bigint where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "xxhash64#30b81390e09c/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | resolves to bigint where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "xxhash64#30b81390e09c/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | resolves to bigint where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "xxhash64#36cc90cab019/ansi_on", @@ -58,11 +58,11 @@ }, { "id": "xxhash64#f5d3d559ad3a/ansi_on", - "reason": "SELECT xxhash64(map('a', 1), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT xxhash64(map('a', 1), array(123), 2) | resolves to bigint where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "xxhash64#f5d3d559ad3a/ansi_off", - "reason": "SELECT xxhash64(map('a', 1), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT xxhash64(map('a', 1), array(123), 2) | resolves to bigint where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "xxhash64#f916e9e6b8e7/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/year.json b/tests/fixtures/analysis/registry-matrix/year.json index c51618a8f..6e4849211 100644 --- a/tests/fixtures/analysis/registry-matrix/year.json +++ b/tests/fixtures/analysis/registry-matrix/year.json @@ -8,14 +8,6 @@ "id": "year#64d0616f8b51/ansi_off", "reason": "SELECT year(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "year#c5aacd8222e2/ansi_on", - "reason": "SELECT year(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "year#c5aacd8222e2/ansi_off", - "reason": "SELECT year(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "year#fe014faf5b51/ansi_on", "reason": "SELECT year(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/zeroifnull.json b/tests/fixtures/analysis/registry-matrix/zeroifnull.json index 5a619af46..cb04548e4 100644 --- a/tests/fixtures/analysis/registry-matrix/zeroifnull.json +++ b/tests/fixtures/analysis/registry-matrix/zeroifnull.json @@ -8,14 +8,6 @@ "id": "zeroifnull#525de99a30fd/ansi_off", "reason": "SELECT zeroifnull(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "zeroifnull#583a6c570fa6/ansi_on", - "reason": "SELECT zeroifnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "zeroifnull#583a6c570fa6/ansi_off", - "reason": "SELECT zeroifnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "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" diff --git a/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapconcat.json b/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapconcat.json index b1ce96fa5..511b0378d 100644 --- a/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapconcat.json +++ b/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapconcat.json @@ -2,31 +2,31 @@ "entries": [ { "query": "SELECT\n map_concat(boolean_map1, boolean_map2) boolean_map,\n map_concat(tinyint_map1, tinyint_map2) tinyint_map,\n map_concat(smallint_map1, smallint_map2) smallint_map,\n map_concat(int_map1, int_map2) int_map,\n map_concat(bigint_map1, bigint_map2) bigint_map,\n map_concat(decimal_map1, decimal_map2) decimal_map,\n map_concat(float_map1, float_map2) float_map,\n map_concat(double_map1, double_map2) double_map,\n map_concat(date_map1, date_map2) date_map,\n map_concat(timestamp_map1, timestamp_map2) timestamp_map,\n map_concat(string_map1, string_map2) string_map,\n map_concat(array_map1, array_map2) array_map,\n map_concat(struct_map1, struct_map2) struct_map,\n map_concat(string_int_map1, string_int_map2) string_int_map,\n map_concat(int_string_map1, int_string_map2) int_string_map\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_concat" + "reason": "TABLE_OR_VIEW_NOT_FOUND: `various_maps`" }, { "query": "SELECT\n map_concat(boolean_map1, int_map2) bi_map\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_concat" + "reason": "TABLE_OR_VIEW_NOT_FOUND: `various_maps`" }, { "query": "SELECT\n map_concat(int_map1, array_map2) ms_map\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_concat" + "reason": "TABLE_OR_VIEW_NOT_FOUND: `various_maps`" }, { "query": "SELECT\n map_concat(int_map1, struct_map2) is_map\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_concat" + "reason": "TABLE_OR_VIEW_NOT_FOUND: `various_maps`" }, { "query": "SELECT\n map_concat(struct_map1, array_map2) ma_map\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_concat" + "reason": "TABLE_OR_VIEW_NOT_FOUND: `various_maps`" }, { "query": "SELECT\n map_concat(tinyint_map1, array_map1) tm_map\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_concat" + "reason": "TABLE_OR_VIEW_NOT_FOUND: `various_maps`" }, { "query": "SELECT\n map_concat(tinyint_map1, smallint_map2) ts_map,\n map_concat(smallint_map1, int_map2) si_map,\n map_concat(int_map1, bigint_map2) ib_map,\n map_concat(bigint_map1, decimal_map2) bd_map,\n map_concat(decimal_map1, float_map2) df_map,\n map_concat(string_map1, date_map2) std_map,\n map_concat(timestamp_map1, string_map2) tst_map,\n map_concat(string_map1, int_map2) sti_map,\n map_concat(int_string_map1, tinyint_map2) istt_map\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_concat" + "reason": "TABLE_OR_VIEW_NOT_FOUND: `various_maps`" } ], "file": "typeCoercion/native/mapconcat", diff --git a/tests/spark-golden/known-failures-cases/group-by.json b/tests/spark-golden/known-failures-cases/group-by.json index b8c3d280e..87c115877 100644 --- a/tests/spark-golden/known-failures-cases/group-by.json +++ b/tests/spark-golden/known-failures-cases/group-by.json @@ -49,7 +49,6 @@ 86, 87, 88, - 89, 90, 91, 92, diff --git a/tests/spark-golden/known-failures-cases/higher-order-functions.json b/tests/spark-golden/known-failures-cases/higher-order-functions.json index 001a9b3d6..0cf4d50da 100644 --- a/tests/spark-golden/known-failures-cases/higher-order-functions.json +++ b/tests/spark-golden/known-failures-cases/higher-order-functions.json @@ -26,9 +26,6 @@ 39, 40, 42, - 44, - 48, - 52, 55, 56, 58, @@ -60,9 +57,6 @@ 73, 77, 81 - ], - "sql-commands": [ - 25 ] }, "file": "higher-order-functions", diff --git a/tests/spark-golden/known-failures-cases/literals.json b/tests/spark-golden/known-failures-cases/literals.json index e0510e115..5951e3c90 100644 --- a/tests/spark-golden/known-failures-cases/literals.json +++ b/tests/spark-golden/known-failures-cases/literals.json @@ -5,9 +5,6 @@ 45, 52 ], - "fn-map": [ - 47 - ], "legacy-configs": [ 59, 60 diff --git a/tests/spark-golden/known-failures-cases/map.json b/tests/spark-golden/known-failures-cases/map.json index 9815c9b34..3b8a9b0d0 100644 --- a/tests/spark-golden/known-failures-cases/map.json +++ b/tests/spark-golden/known-failures-cases/map.json @@ -3,16 +3,6 @@ "fn-array": [ 0 ], - "fn-map": [ - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9 - ], "nested-interval-types": [ 1 ] diff --git a/tests/spark-golden/known-failures-cases/misc-functions.json b/tests/spark-golden/known-failures-cases/misc-functions.json index 4d1d1cf00..1c171cc2a 100644 --- a/tests/spark-golden/known-failures-cases/misc-functions.json +++ b/tests/spark-golden/known-failures-cases/misc-functions.json @@ -4,11 +4,9 @@ 4 ], "fn-misc": [ - 6, 7, 9, - 11, - 16 + 11 ] }, "file": "misc-functions", diff --git a/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json b/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json index 5190ea746..faeb84683 100644 --- a/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json +++ b/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json @@ -26,9 +26,6 @@ 39, 40, 42, - 44, - 48, - 52, 55, 56, 58, @@ -60,9 +57,6 @@ 73, 77, 81 - ], - "sql-commands": [ - 25 ] }, "file": "nonansi/higher-order-functions", diff --git a/tests/spark-golden/known-failures-cases/nonansi/literals.json b/tests/spark-golden/known-failures-cases/nonansi/literals.json index 91a5b6e86..c87ac9873 100644 --- a/tests/spark-golden/known-failures-cases/nonansi/literals.json +++ b/tests/spark-golden/known-failures-cases/nonansi/literals.json @@ -5,9 +5,6 @@ 45, 52 ], - "fn-map": [ - 47 - ], "legacy-configs": [ 59, 60 diff --git a/tests/spark-golden/known-failures-cases/nonansi/map.json b/tests/spark-golden/known-failures-cases/nonansi/map.json index e2afea772..be720e200 100644 --- a/tests/spark-golden/known-failures-cases/nonansi/map.json +++ b/tests/spark-golden/known-failures-cases/nonansi/map.json @@ -3,16 +3,6 @@ "fn-array": [ 0 ], - "fn-map": [ - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9 - ], "nested-interval-types": [ 1 ] diff --git a/tests/spark-golden/known-failures-cases/pipe-operators.json b/tests/spark-golden/known-failures-cases/pipe-operators.json index 9f42c7fa2..53f4415a0 100644 --- a/tests/spark-golden/known-failures-cases/pipe-operators.json +++ b/tests/spark-golden/known-failures-cases/pipe-operators.json @@ -260,7 +260,6 @@ 6, 7, 8, - 12, 24, 314, 315, diff --git a/tests/spark-golden/known-failures-cases/pivot.json b/tests/spark-golden/known-failures-cases/pivot.json index a2afc9741..a4ccac3b9 100644 --- a/tests/spark-golden/known-failures-cases/pivot.json +++ b/tests/spark-golden/known-failures-cases/pivot.json @@ -11,9 +11,6 @@ 28, 29, 30 - ], - "sql-commands": [ - 2 ] }, "file": "pivot", diff --git a/tests/spark-golden/known-failures-cases/udf/udf-pivot.json b/tests/spark-golden/known-failures-cases/udf/udf-pivot.json index dce7ff932..d6a52702f 100644 --- a/tests/spark-golden/known-failures-cases/udf/udf-pivot.json +++ b/tests/spark-golden/known-failures-cases/udf/udf-pivot.json @@ -28,9 +28,6 @@ 27, 28, 29 - ], - "sql-commands": [ - 2 ] }, "file": "udf/udf-pivot", diff --git a/tests/spark-golden/known-failures-cases/union.json b/tests/spark-golden/known-failures-cases/union.json index 274bf7b32..ae02da731 100644 --- a/tests/spark-golden/known-failures-cases/union.json +++ b/tests/spark-golden/known-failures-cases/union.json @@ -5,9 +5,6 @@ 14, 15 ], - "fn-map": [ - 10 - ], "sql-commands": [ 2, 12, diff --git a/tests/spark-golden/known-failures.json b/tests/spark-golden/known-failures.json index 83eb0891a..7375d4a1c 100644 --- a/tests/spark-golden/known-failures.json +++ b/tests/spark-golden/known-failures.json @@ -45,11 +45,6 @@ "summary": "JSON functions", "task": "P2-T031" }, - "fn-map": { - "kind": "unsupported", - "summary": "map functions", - "task": "P2-T029" - }, "fn-misc": { "kind": "unsupported", "summary": "misc functions (typeof, uuid, rand, raise_error, vector, current_*)", @@ -359,12 +354,6 @@ "collection" ] }, - { - "category": "fn-map", - "family": [ - "map" - ] - }, { "category": "fn-json", "family": [