From 1634b12c516c85f6c8f417ec7adb15f1ca1a1f96 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Sun, 25 Oct 2026 17:28:35 +0100 Subject: [PATCH 1/4] Implement Spark map functions (P2-T029) Add the nine scalar functions of Spark 4.2's map family: map, map_concat, map_contains_key, map_keys, map_values, map_entries, map_from_arrays, map_from_entries and str_to_map. The lambda forms (map_filter, map_zip_with, transform_keys/values) stay out as higher-order functions, as do element_at and try_element_at. Typing follows the Spark 4.2 sources and the recorded 4.2 runs, with signatures and result rules in krishiv-functions and implicit casts in the analyzer (keys and values of map meet separately, map_concat needs every map and the same type under ANSI, map_contains_key meets the key without string promotion). The kernels in krishiv-kernels build maps row by row over Arrow ListArray, MapArray and StructArray directly, comparing keys with Spark's equality and hashing with the observable Murmur3. A null key raises NULL_MAP_KEY and a duplicate key raises DUPLICATED_MAP_KEY, or keeps the last value under spark.sql.mapKeyDedupPolicy=LAST_WIN (new session config, honoured when folding and executing, carried to workers behind a new map_key_dedup_policy plan-codec feature). The golden fn-map category goes from 10 failing statements to none, and the registry matrix covers the 448 map cases. Unverified against a Spark run: the empty map() and map_concat() forms and the INVALID_MAP_KEY_TYPE paths, which follow the sources and are pinned by unit tests. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- Cargo.lock | 1 + crates/krishiv-cli/src/sql.rs | 18 + crates/krishiv-common/src/config/registry.rs | 16 + crates/krishiv-common/src/config/tests.rs | 25 + crates/krishiv-exec/src/physical/mod.rs | 6 +- crates/krishiv-exec/src/planner/eval/func.rs | 11 +- crates/krishiv-exec/src/planner/eval/mod.rs | 13 +- crates/krishiv-exec/src/profile/tests.rs | 1 + crates/krishiv-exec/tests/planner/physical.rs | 1 + crates/krishiv-exec/tests/planner/write.rs | 1 + crates/krishiv-functions/CLAUDE.md | 6 +- crates/krishiv-functions/Cargo.toml | 3 + .../src/python_wrappers/table.rs | 13 +- crates/krishiv-functions/src/registry/defs.rs | 1 + crates/krishiv-functions/src/registry/map.rs | 332 +++ crates/krishiv-functions/src/registry/mod.rs | 1 + .../krishiv-functions/src/registry/tests.rs | 181 ++ crates/krishiv-functions/src/scalar/map.rs | 381 ++++ crates/krishiv-functions/src/scalar/mod.rs | 49 +- crates/krishiv-functions/src/scalar/regex.rs | 26 + .../src/scalar/regex/tests.rs | 4 +- .../krishiv-functions/src/scalar/tests/map.rs | 545 +++++ .../krishiv-functions/src/scalar/tests/mod.rs | 3 +- crates/krishiv-functions/src/signature.rs | 23 + crates/krishiv-kernels/CLAUDE.md | 6 + crates/krishiv-kernels/src/lib.rs | 1 + crates/krishiv-kernels/src/map.rs | 1790 +++++++++++++++++ crates/krishiv-plan-codec/src/decode.rs | 1 + crates/krishiv-plan-codec/src/encode.rs | 1 + crates/krishiv-plan-codec/src/features.rs | 4 + .../src/proto/krishiv.plan.v1.pb.rs | 5 + .../tests/common/inventory.rs | 12 + .../map_key_dedup_policy.bin | Bin 0 -> 352 bytes crates/krishiv-plan-codec/tests/roundtrip.rs | 2 +- crates/krishiv-plan/src/analyzer/coerce.rs | 126 +- crates/krishiv-plan/src/analyzer/exprs.rs | 32 +- crates/krishiv-plan/src/analyzer/fold.rs | 32 +- crates/krishiv-plan/src/analyzer/mod.rs | 13 +- .../tests/datetime_calendar.rs | 5 +- proto/krishiv/plan/v1/plan.proto | 4 + python/krishiv/sql/_generated_functions.py | 61 + python/krishiv/sql/_generated_functions.pyi | 20 + python/tests/_pyspark_signatures.py | 9 + python/tests/test_generated_functions.py | 1 + .../analysis/registry-matrix/%26.json | 16 - .../analysis/registry-matrix/%3C%3C.json | 16 - .../analysis/registry-matrix/%3E%3E%3E.json | 8 - .../analysis/registry-matrix/%3E%3E.json | 8 - .../analysis/registry-matrix/%5E.json | 16 - .../analysis/registry-matrix/%7C.json | 16 - .../analysis/registry-matrix/%7E.json | 8 - .../analysis/registry-matrix/abs.json | 8 - .../analysis/registry-matrix/acos.json | 8 - .../analysis/registry-matrix/acosh.json | 8 - .../analysis/registry-matrix/add_months.json | 16 - .../analysis/registry-matrix/any_value.json | 8 - .../analysis/registry-matrix/asin.json | 8 - .../analysis/registry-matrix/asinh.json | 8 - .../analysis/registry-matrix/assert_true.json | 8 - .../analysis/registry-matrix/atan.json | 8 - .../analysis/registry-matrix/atan2.json | 16 - .../analysis/registry-matrix/atanh.json | 8 - .../analysis/registry-matrix/bin.json | 8 - .../analysis/registry-matrix/bit_count.json | 8 - .../analysis/registry-matrix/bit_get.json | 16 - .../analysis/registry-matrix/bround.json | 16 - .../analysis/registry-matrix/btrim.json | 24 - .../analysis/registry-matrix/cbrt.json | 8 - .../analysis/registry-matrix/ceil.json | 24 - .../analysis/registry-matrix/ceiling.json | 24 - .../analysis/registry-matrix/char_length.json | 8 - .../registry-matrix/character_length.json | 8 - .../analysis/registry-matrix/coalesce.json | 24 - .../analysis/registry-matrix/contains.json | 16 - .../analysis/registry-matrix/conv.json | 24 - .../registry-matrix/convert_timezone.json | 40 - .../analysis/registry-matrix/cos.json | 8 - .../analysis/registry-matrix/cosh.json | 8 - .../analysis/registry-matrix/cot.json | 8 - .../analysis/registry-matrix/crc32.json | 8 - .../analysis/registry-matrix/csc.json | 8 - .../analysis/registry-matrix/date_add.json | 16 - .../analysis/registry-matrix/date_diff.json | 16 - .../analysis/registry-matrix/date_part.json | 12 +- .../analysis/registry-matrix/date_sub.json | 16 - .../analysis/registry-matrix/date_trunc.json | 16 - .../analysis/registry-matrix/dateadd.json | 16 - .../analysis/registry-matrix/datediff.json | 16 - .../analysis/registry-matrix/day.json | 8 - .../analysis/registry-matrix/dayname.json | 8 - .../analysis/registry-matrix/dayofmonth.json | 8 - .../analysis/registry-matrix/dayofweek.json | 8 - .../analysis/registry-matrix/dayofyear.json | 8 - .../analysis/registry-matrix/degrees.json | 8 - .../analysis/registry-matrix/endswith.json | 16 - .../analysis/registry-matrix/equal_null.json | 16 - .../analysis/registry-matrix/exp.json | 8 - .../analysis/registry-matrix/expm1.json | 8 - .../analysis/registry-matrix/first.json | 8 - .../analysis/registry-matrix/first_value.json | 8 - .../analysis/registry-matrix/floor.json | 24 - .../registry-matrix/format_number.json | 16 - .../registry-matrix/from_utc_timestamp.json | 16 - .../analysis/registry-matrix/getbit.json | 16 - .../analysis/registry-matrix/greatest.json | 40 - .../analysis/registry-matrix/hash.json | 8 +- .../analysis/registry-matrix/hex.json | 8 - .../analysis/registry-matrix/hour.json | 8 - .../analysis/registry-matrix/hypot.json | 16 - .../fixtures/analysis/registry-matrix/if.json | 24 - .../analysis/registry-matrix/ifnull.json | 12 +- .../analysis/registry-matrix/isnan.json | 8 - .../analysis/registry-matrix/isnotnull.json | 8 - .../analysis/registry-matrix/isnull.json | 8 - .../analysis/registry-matrix/last.json | 8 - .../analysis/registry-matrix/last_day.json | 8 - .../analysis/registry-matrix/last_value.json | 8 - .../analysis/registry-matrix/lcase.json | 8 - .../analysis/registry-matrix/least.json | 40 - .../analysis/registry-matrix/length.json | 8 - .../fixtures/analysis/registry-matrix/ln.json | 8 - .../analysis/registry-matrix/log.json | 16 - .../analysis/registry-matrix/log10.json | 8 - .../analysis/registry-matrix/log1p.json | 8 - .../analysis/registry-matrix/log2.json | 8 - .../analysis/registry-matrix/lower.json | 8 - .../analysis/registry-matrix/lpad.json | 40 - .../analysis/registry-matrix/ltrim.json | 8 - .../analysis/registry-matrix/make_date.json | 24 - .../analysis/registry-matrix/map.json | 134 ++ .../analysis/registry-matrix/map_concat.json | 70 + .../registry-matrix/map_contains_key.json | 70 + .../analysis/registry-matrix/map_entries.json | 38 + .../registry-matrix/map_from_arrays.json | 398 ++++ .../registry-matrix/map_from_entries.json | 62 + .../analysis/registry-matrix/map_keys.json | 38 + .../analysis/registry-matrix/map_values.json | 38 + .../analysis/registry-matrix/max_by.json | 4 +- .../analysis/registry-matrix/md5.json | 8 - .../analysis/registry-matrix/min_by.json | 4 +- .../analysis/registry-matrix/minute.json | 8 - .../analysis/registry-matrix/mod.json | 16 - .../analysis/registry-matrix/month.json | 8 - .../analysis/registry-matrix/monthname.json | 8 - .../registry-matrix/months_between.json | 40 - .../analysis/registry-matrix/nanvl.json | 16 - .../analysis/registry-matrix/negative.json | 8 - .../analysis/registry-matrix/next_day.json | 16 - .../analysis/registry-matrix/nth_value.json | 4 +- .../analysis/registry-matrix/ntile.json | 4 +- .../analysis/registry-matrix/nullif.json | 16 - .../analysis/registry-matrix/nullifzero.json | 8 - .../analysis/registry-matrix/nvl.json | 12 +- .../analysis/registry-matrix/nvl2.json | 24 - .../analysis/registry-matrix/pmod.json | 16 - .../analysis/registry-matrix/positive.json | 8 - .../analysis/registry-matrix/pow.json | 16 - .../analysis/registry-matrix/power.json | 16 - .../analysis/registry-matrix/quarter.json | 8 - .../analysis/registry-matrix/radians.json | 8 - .../analysis/registry-matrix/raise_error.json | 8 - .../analysis/registry-matrix/regexp.json | 16 - .../registry-matrix/regexp_count.json | 16 - .../registry-matrix/regexp_extract.json | 24 - .../registry-matrix/regexp_instr.json | 16 - .../analysis/registry-matrix/regexp_like.json | 16 - .../registry-matrix/regexp_replace.json | 24 - .../registry-matrix/regexp_substr.json | 16 - .../analysis/registry-matrix/replace.json | 24 - .../analysis/registry-matrix/rint.json | 8 - .../analysis/registry-matrix/round.json | 16 - .../analysis/registry-matrix/rpad.json | 40 - .../analysis/registry-matrix/rtrim.json | 8 - .../analysis/registry-matrix/sec.json | 8 - .../analysis/registry-matrix/second.json | 8 - .../analysis/registry-matrix/sha.json | 8 - .../analysis/registry-matrix/sha1.json | 8 - .../analysis/registry-matrix/sha2.json | 16 - .../analysis/registry-matrix/shiftleft.json | 16 - .../analysis/registry-matrix/shiftright.json | 16 - .../registry-matrix/shiftrightunsigned.json | 16 - .../analysis/registry-matrix/sign.json | 8 - .../analysis/registry-matrix/signum.json | 8 - .../analysis/registry-matrix/sin.json | 8 - .../analysis/registry-matrix/sinh.json | 8 - .../analysis/registry-matrix/sqrt.json | 8 - .../analysis/registry-matrix/startswith.json | 16 - .../analysis/registry-matrix/str_to_map.json | 134 ++ .../analysis/registry-matrix/substr.json | 40 - .../analysis/registry-matrix/substring.json | 40 - .../analysis/registry-matrix/tan.json | 8 - .../analysis/registry-matrix/tanh.json | 8 - .../analysis/registry-matrix/to_char.json | 16 - .../analysis/registry-matrix/to_number.json | 16 - .../registry-matrix/to_utc_timestamp.json | 16 - .../analysis/registry-matrix/to_varchar.json | 16 - .../analysis/registry-matrix/trim.json | 8 - .../analysis/registry-matrix/trunc.json | 16 - .../analysis/registry-matrix/try_add.json | 16 - .../analysis/registry-matrix/try_divide.json | 16 - .../analysis/registry-matrix/try_mod.json | 16 - .../registry-matrix/try_multiply.json | 16 - .../registry-matrix/try_subtract.json | 16 - .../registry-matrix/try_to_number.json | 16 - .../analysis/registry-matrix/ucase.json | 8 - .../analysis/registry-matrix/unix_date.json | 8 - .../analysis/registry-matrix/upper.json | 8 - .../analysis/registry-matrix/weekday.json | 8 - .../analysis/registry-matrix/weekofyear.json | 8 - .../analysis/registry-matrix/xxhash64.json | 8 +- .../analysis/registry-matrix/year.json | 8 - .../analysis/registry-matrix/zeroifnull.json | 8 - .../typeCoercion/native/mapconcat.json | 14 +- .../higher-order-functions.json | 3 +- .../known-failures-cases/literals.json | 3 - .../known-failures-cases/map.json | 10 - .../known-failures-cases/misc-functions.json | 3 +- .../nonansi/higher-order-functions.json | 3 +- .../nonansi/literals.json | 3 - .../known-failures-cases/nonansi/map.json | 10 - .../known-failures-cases/union.json | 3 - tests/spark-golden/known-failures.json | 11 - 222 files changed, 4763 insertions(+), 2192 deletions(-) create mode 100644 crates/krishiv-functions/src/registry/map.rs create mode 100644 crates/krishiv-functions/src/scalar/map.rs create mode 100644 crates/krishiv-functions/src/scalar/tests/map.rs create mode 100644 crates/krishiv-kernels/src/map.rs create mode 100644 crates/krishiv-plan-codec/tests/golden/map_key_dedup_policy/map_key_dedup_policy.bin create mode 100644 tests/fixtures/analysis/registry-matrix/map.json create mode 100644 tests/fixtures/analysis/registry-matrix/map_concat.json create mode 100644 tests/fixtures/analysis/registry-matrix/map_contains_key.json create mode 100644 tests/fixtures/analysis/registry-matrix/map_entries.json create mode 100644 tests/fixtures/analysis/registry-matrix/map_from_arrays.json create mode 100644 tests/fixtures/analysis/registry-matrix/map_from_entries.json create mode 100644 tests/fixtures/analysis/registry-matrix/map_keys.json create mode 100644 tests/fixtures/analysis/registry-matrix/map_values.json create mode 100644 tests/fixtures/analysis/registry-matrix/str_to_map.json diff --git a/Cargo.lock b/Cargo.lock index eb1b53d4f..d4cc11622 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1540,6 +1540,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 cb84a9353..87804d231 100644 --- a/crates/krishiv-cli/src/sql.rs +++ b/crates/krishiv-cli/src/sql.rs @@ -416,6 +416,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}>"), } } diff --git a/crates/krishiv-common/src/config/registry.rs b/crates/krishiv-common/src/config/registry.rs index 731a2b031..bca8ae3f6 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, @@ -91,12 +92,14 @@ 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), ("krishiv.io.metadataCacheBytes", &IO_METADATA_CACHE_BYTES), ("krishiv.io.multipartPartBytes", &IO_MULTIPART_PART_BYTES), ("krishiv.runtimeFilter.enabled", &RUNTIME_FILTER_ENABLED), + ("krishiv.sql.mapKeyDedupPolicy", &MAP_KEY_DEDUP_POLICY), ("krishiv.io.lateMaterialization", &IO_LATE_MATERIALIZATION), ( "krishiv.memory.spillWaitTimeout", @@ -252,6 +255,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 17c825681..13c6bf989 100644 --- a/crates/krishiv-exec/src/physical/mod.rs +++ b/crates/krishiv-exec/src/physical/mod.rs @@ -157,6 +157,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; @@ -469,7 +473,7 @@ plan_data!( Partitioned, } ); -plan_data!(struct ExprEnv { ansi, zone, query_start_micros, user }); +plan_data!(struct ExprEnv { ansi, 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 e469091f7..495202eb1 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; @@ -28,7 +29,10 @@ pub(super) fn compile( .zip(&args) .map(|(ir, compiled)| match &ir.node { ExprNode::Literal(l) => literal_array(l).map(BindArg::Literal), - _ => Ok(BindArg::Column(compiled.data_type().clone())), + _ => Ok(BindArg::Column { + data_type: compiled.data_type().clone(), + nullable: compiled.nullable(), + }), }) .collect::>>()?; let out = f.data_type.to_arrow(); @@ -51,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)); let function = bind_scalar(name, &bind_args, &opts).map_err(|err| { if err.error_class() == krishiv_common::error::ErrorClass::KrishivUnsupportedFeature { diff --git a/crates/krishiv-exec/src/planner/eval/mod.rs b/crates/krishiv-exec/src/planner/eval/mod.rs index 9d6510f25..7646d8ef8 100644 --- a/crates/krishiv-exec/src/planner/eval/mod.rs +++ b/crates/krishiv-exec/src/planner/eval/mod.rs @@ -36,7 +36,7 @@ use std::sync::Arc; 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, SESSION_TIME_ZONE}; +use krishiv_common::config::{ANSI_ENABLED, Config, MAP_KEY_DEDUP_POLICY, SESSION_TIME_ZONE}; use krishiv_kernels::KernelCtx; use krishiv_plan::{ AttrId, Builtin, Expr, ExprNode, FunctionId, FunctionKind, Literal, ResolvedExpr, @@ -164,6 +164,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, } impl EvalEnv { @@ -176,6 +180,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() @@ -187,6 +195,7 @@ impl EvalEnv { kernels: KernelCtx::new(), query_start_micros, user, + map_key_dedup_last_win, } } @@ -198,6 +207,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, } } @@ -208,6 +218,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 e8d42dd65..9d61b44f0 100644 --- a/crates/krishiv-exec/src/profile/tests.rs +++ b/crates/krishiv-exec/src/profile/tests.rs @@ -20,6 +20,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 0b9bba51c..4914288c7 100644 --- a/crates/krishiv-exec/tests/planner/physical.rs +++ b/crates/krishiv-exec/tests/planner/physical.rs @@ -166,6 +166,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 0fe986ad4..707790dc6 100644 --- a/crates/krishiv-exec/tests/planner/write.rs +++ b/crates/krishiv-exec/tests/planner/write.rs @@ -126,6 +126,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 4a1e21563..7dadfe8d0 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`, - `datetime`, `math`, `arith`, `hash`, `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`, `map`, `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`), `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,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,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 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/table.rs b/crates/krishiv-functions/src/python_wrappers/table.rs index c6c950a9c..ed3c0f3cb 100644 --- a/crates/krishiv-functions/src/python_wrappers/table.rs +++ b/crates/krishiv-functions/src/python_wrappers/table.rs @@ -107,6 +107,10 @@ pub(super) fn rows() -> Vec { "log1p", "log2", "lower", + "map_entries", + "map_from_entries", + "map_keys", + "map_values", "max", "md5", "min", @@ -207,7 +211,7 @@ pub(super) fn rows() -> Vec { "col: ColumnOrName, ignoreNulls: bool | Column = None", )); } - for name in ["coalesce", "hash", "xxhash64"] { + for name in ["coalesce", "hash", "map_concat", "xxhash64"] { rows.push(Row::new(name, "*cols: ColumnOrName")); } for name in ["lpad", "rpad"] { @@ -225,6 +229,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 f46573e89..8cf8983e3 100644 --- a/crates/krishiv-functions/src/registry/defs.rs +++ b/crates/krishiv-functions/src/registry/defs.rs @@ -813,6 +813,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 da1b6b7a9..aa121ce10 100644 --- a/crates/krishiv-functions/src/registry/mod.rs +++ b/crates/krishiv-functions/src/registry/mod.rs @@ -18,6 +18,7 @@ mod catalog; mod conditional; mod defs; mod hashing; +mod map; mod math; mod number; mod predicate; diff --git a/crates/krishiv-functions/src/registry/tests.rs b/crates/krishiv-functions/src/registry/tests.rs index 669337917..b1b201a58 100644 --- a/crates/krishiv-functions/src/registry/tests.rs +++ b/crates/krishiv-functions/src/registry/tests.rs @@ -1518,3 +1518,184 @@ fn regex_signatures() { let r = result("regexp_count", &[s, null_ty()], &[]).unwrap(); 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 + ) + ); +} diff --git a/crates/krishiv-functions/src/scalar/map.rs b/crates/krishiv-functions/src/scalar/map.rs new file mode 100644 index 000000000..9b31f629a --- /dev/null +++ b/crates/krishiv-functions/src/scalar/map.rs @@ -0,0 +1,381 @@ +// 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. + let splitter = + |cache: &mut HashMap, d: &str| -> Result { + if let Some(s) = cache.get(d) { + return Ok(s.clone()); + } + let s = Splitter::new(d)?; + cache.insert(d.to_owned(), s.clone()); + Ok(s) + }; + 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 def9ab20c..c45075a38 100644 --- a/crates/krishiv-functions/src/scalar/mod.rs +++ b/crates/krishiv-functions/src/scalar/mod.rs @@ -28,6 +28,7 @@ mod arith; mod bitwise; mod datetime; mod hash; +mod map; mod math; mod number; mod predicate; @@ -45,6 +46,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}; @@ -53,8 +55,15 @@ use args::{Inputs, broadcast, internal, unsupported}; #[derive(Debug, Clone)] #[non_exhaustive] pub enum BindArg { - /// A value computed per row, of this type. - Column(DataType), + /// A value computed per row, of this type; `nullable` is whether it + /// may be null (the map family reads it for the value nullability of + /// the map type it returns). + Column { + /// The argument's Arrow type. + data_type: DataType, + /// Whether the argument may be null. + nullable: bool, + }, /// A literal, as a one-row array. Some functions need the value to /// bind (the field of `extract`); others treat it as a column. Literal(ArrayRef), @@ -65,15 +74,28 @@ impl BindArg { #[must_use] pub fn data_type(&self) -> DataType { match self { - Self::Column(t) => t.clone(), + Self::Column { data_type, .. } => data_type.clone(), Self::Literal(a) => a.data_type().clone(), } } + + /// Whether the argument may be null: the flag for a column, whether + /// the value is null for a literal. + #[must_use] + pub fn nullable(&self) -> bool { + match self { + Self::Column { nullable, .. } => *nullable, + Self::Literal(a) => a.data_type() == &DataType::Null || a.null_count() > 0, + } + } } impl From for BindArg { fn from(t: DataType) -> Self { - Self::Column(t) + Self::Column { + data_type: t, + nullable: true, + } } } @@ -97,6 +119,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, } @@ -112,6 +137,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"), } } @@ -144,6 +170,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 { @@ -283,13 +316,14 @@ 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); 10] = [ +const FAMILIES: [(&[&str], Binder); 11] = [ (string::NAMES, string::bind), (datetime::NAMES, datetime::bind), (math::NAMES, math::bind), (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), @@ -309,14 +343,15 @@ 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, math and arithmetic +/// arguments, `spark.sql.ansi.enabled` and (for the map family) +/// `spark.sql.mapKeyDedupPolicy`: the string, math, arithmetic and map /// families. 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. #[must_use] pub fn is_argument_pure(name: &str) -> bool { let lower = name.to_ascii_lowercase(); - [string::NAMES, math::NAMES, arith::NAMES] + [string::NAMES, math::NAMES, arith::NAMES, map::NAMES] .iter() .any(|names| names.contains(&lower.as_str())) } diff --git a/crates/krishiv-functions/src/scalar/regex.rs b/crates/krishiv-functions/src/scalar/regex.rs index 58d03448a..9fe34384a 100644 --- a/crates/krishiv-functions/src/scalar/regex.rs +++ b/crates/krishiv-functions/src/scalar/regex.rs @@ -133,6 +133,7 @@ pub(super) fn bind(name: &str, args: &[BindArg], _opts: &BindOptions) -> FamilyR } /// A pattern compiled from its Java source. +#[derive(Clone)] struct Compiled { /// The pattern as written, for the error message. source: String, @@ -526,6 +527,31 @@ 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`. +#[derive(Clone)] +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/regex/tests.rs b/crates/krishiv-functions/src/scalar/regex/tests.rs index a77ae6d16..405da8a97 100644 --- a/crates/krishiv-functions/src/scalar/regex/tests.rs +++ b/crates/krishiv-functions/src/scalar/regex/tests.rs @@ -1287,8 +1287,8 @@ fn regex_bind_errors() { use crate::scalar::{BindArg, bind_scalar}; use arrow_schema::DataType; let opts = crate::scalar::BindOptions::new(); - let utf8 = || BindArg::Column(DataType::Utf8); - let int = || BindArg::Column(DataType::Int32); + let utf8 = || BindArg::from(DataType::Utf8); + let int = || BindArg::from(DataType::Int32); for (name, args) in [ ("regexp_extract", vec![utf8()]), ("regexp_extract", vec![utf8(), utf8(), utf8(), int()]), diff --git a/crates/krishiv-functions/src/scalar/tests/map.rs b/crates/krishiv-functions/src/scalar/tests/map.rs new file mode 100644 index 000000000..b9f0b99fb --- /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 { + data_type: DataType::Int32, + nullable: false, + }, + BindArg::Column { + data_type: 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 2c9ce543c..1fad16ca0 100644 --- a/crates/krishiv-functions/src/scalar/tests/mod.rs +++ b/crates/krishiv-functions/src/scalar/tests/mod.rs @@ -564,6 +564,7 @@ fn results_are_checked_against_the_binding() { mod bitwise; mod calendar; mod families; +mod map; mod number; mod predicate; @@ -579,7 +580,7 @@ fn session_user_and_local_clock() { let out: Vec<_> = out.as_string::().iter().collect(); assert_eq!(out, [Some("etl"), Some("etl"), Some("etl")]); } - assert!(bind_scalar("current_user", &[BindArg::Column(DataType::Int32)], &opts).is_err()); + assert!(bind_scalar("current_user", &[BindArg::from(DataType::Int32)], &opts).is_err()); // `localtimestamp` is the wall clock of the session zone, without a zone. let micros = 1_700_000_000_123_456; let opts = BindOptions::new() diff --git a/crates/krishiv-functions/src/signature.rs b/crates/krishiv-functions/src/signature.rs index aa8bd19aa..a6bdd1ecd 100644 --- a/crates/krishiv-functions/src/signature.rs +++ b/crates/krishiv-functions/src/signature.rs @@ -294,6 +294,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. @@ -307,6 +312,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. @@ -370,6 +377,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, @@ -416,6 +436,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 89e23dc43..a15b78451 100644 --- a/crates/krishiv-kernels/CLAUDE.md +++ b/crates/krishiv-kernels/CLAUDE.md @@ -42,6 +42,11 @@ Vectorised compute kernels (SIMD) with Spark semantics, Spark-observable Murmur3 their elements, structs their fields, maps each key then value). A column is resolved to a `Col` plan once, rows only match on the variant. The analyzer's MAP rejection (`DATATYPE_MISMATCH.HASH_MAP_TYPE` without `spark.sql.legacy.allowHashOnMapType`) is the caller's check. Unsupported types (dictionary, 256-bit decimal, time of day, month-day-nano interval) are `KRISHIV_UNSUPPORTED_FEATURE`. +- `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 @@ -77,6 +82,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/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 517fdc93f..df3cf0432 100644 --- a/crates/krishiv-kernels/src/lib.rs +++ b/crates/krishiv-kernels/src/lib.rs @@ -48,6 +48,7 @@ pub mod error; pub mod float; pub mod hash; pub mod integer; +pub mod 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..e3c2b4be4 --- /dev/null +++ b/crates/krishiv-kernels/src/map.rs @@ -0,0 +1,1790 @@ +// 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()) +} + +/// 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 (f, g) in af.iter().zip(bf.iter()) { + let (x, y) = (a.column_by_name(f.name()), b.column_by_name(g.name())); + let (Some(x), Some(y)) = (x, y) else { + return Err(internal("a struct key field is missing")); + }; + 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 in b.field_builders_mut() { + downcast::(f.as_mut())?.append_null(); + } + 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.get(at).copied().unwrap_or(0); + 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) -> KrishivError { + 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) -> String { + use DataType as T; + match keys.data_type() { + T::Utf8 | T::Utf8View | T::LargeUtf8 => string_value(keys, key).to_owned(), + T::Boolean => keys.as_boolean().value(key).to_string(), + T::Int8 => keys.as_primitive::().value(key).to_string(), + T::Int16 => keys.as_primitive::().value(key).to_string(), + T::Int32 => keys.as_primitive::().value(key).to_string(), + T::Int64 => keys.as_primitive::().value(key).to_string(), + T::UInt8 => keys.as_primitive::().value(key).to_string(), + T::UInt16 => keys.as_primitive::().value(key).to_string(), + T::UInt32 => keys.as_primitive::().value(key).to_string(), + T::UInt64 => keys.as_primitive::().value(key).to_string(), + T::Float32 => { + let v = keys.as_primitive::().value(key); + if v.is_nan() { + "NaN".to_owned() + } else { + format!("{v:?}") + } + } + T::Float64 => { + let v = keys.as_primitive::().value(key); + if v.is_nan() { + "NaN".to_owned() + } else { + format!("{v:?}") + } + } + T::Decimal128(_, scale) => { + decimal_text(keys.as_primitive::().value(key), *scale) + } + T::Binary | T::BinaryView | T::LargeBinary => { + format!("{:?}", binary_value(keys, key)) + } + T::Date32 => keys.as_primitive::().value(key).to_string(), + T::Timestamp(..) => keys + .as_primitive::() + .value(key) + .to_string(), + T::List(_) | T::LargeList(_) => { + let (from, to) = list_range(keys, key).unwrap_or((0, 0)); + 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) + }); + } + 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) + }); + } + format!("[{}]", parts.join(", ")) + } + _ => format!("{:?}", keys), + } +} + +/// A decimal unscaled value with `scale` digits after the point. +fn decimal_text(unscaled: i128, scale: i8) -> String { + let scale = usize::try_from(scale.max(0)).unwrap_or(0); + 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 { + format!("{sign}{int}") + } else { + 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.get(at).copied().unwrap_or(0)); + 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 h = hash + .get(base.get(mi).copied().unwrap_or(0).saturating_add(p)) + .copied() + .unwrap_or(0); + 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), + OffsetBuffer::new(m.value_offsets().to_vec().into()), + 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), + OffsetBuffer::new(m.value_offsets().to_vec().into()), + 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.get(p).copied().unwrap_or(0)); + 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 +/// the whole result 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 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.get(p).copied().unwrap_or(0)); + 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 voids the whole result. + return whole_null(rows, entries); + } + nulls.append(true); + per_row.push(row); + } + assemble( + entries, + &Deduped::of(per_row, policy, &ordered)?, + nulls.finish(), + ) +} + +/// An all-null [`MapArray`] of `rows` rows over `entries`. +fn whole_null(rows: usize, entries: &FieldRef) -> 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 empty_keys = make_builder(fields[0].data_type(), 0).finish(); + let empty_values = make_builder(fields[1].data_type(), 0).finish(); + let structs = + StructArray::try_new(fields, vec![empty_keys, empty_values], None).map_err(internal)?; + let offsets = OffsetBuffer::new(vec![0_i32; rows.saturating_add(1)].into()); + let mut nulls = NullBufferBuilder::new(rows); + for _ in 0..rows { + nulls.append(false); + } + MapArray::try_new(Arc::clone(entries), offsets, structs, nulls.finish(), false) + .map_err(internal) +} + +/// `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.get(p).copied().unwrap_or(0)); + 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); + 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), + (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 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 voids the whole result, not just its 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) && m.is_null(1)); + + // 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), "1.00"); + assert_eq!(decimal_text(-5, 3), "-0.005"); + assert_eq!(decimal_text(0, 0), "0"); + assert_eq!(decimal_text(12345, 0), "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); + } +} diff --git a/crates/krishiv-plan-codec/src/decode.rs b/crates/krishiv-plan-codec/src/decode.rs index 7ba9cb913..086baaf6d 100644 --- a/crates/krishiv-plan-codec/src/decode.rs +++ b/crates/krishiv-plan-codec/src/decode.rs @@ -291,6 +291,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 8c20272f8..a3041ac34 100644 --- a/crates/krishiv-plan-codec/src/encode.rs +++ b/crates/krishiv-plan-codec/src/encode.rs @@ -130,6 +130,7 @@ fn env(env: &ExprEnv) -> pb::ExprEnv { zone: env.zone, query_start_micros: env.query_start_micros, user: env.user.to_string(), + 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 b714aee78..faa7f8e7b 100644 --- a/crates/krishiv-plan-codec/src/features.rs +++ b/crates/krishiv-plan-codec/src/features.rs @@ -120,6 +120,7 @@ registry! { (expand, Expand, 5, Semantic, "The `Expand` node and its `NullOf` project item (ROLLUP, CUBE, GROUPING SETS)."), (join_build_preserved, JoinBuildPreserved, POST_MIGRATION_READER_VERSION, Optimization, "Joins that build their preserved side (`RightSemi`, `RightAnti`, `RightOuter`); without it the planner builds the other side (`LeftSemi`, `LeftAnti`, `LeftOuter`)."), (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)."), (window, Window, 4, Semantic, "The `Window` node and its functions."), (window_frame_offsets, WindowFrameOffsets, POST_MIGRATION_READER_VERSION, Semantic, "`ROWS` window frame bounds at an offset from the current row (`n PRECEDING`, `n FOLLOWING`)."), @@ -430,6 +431,9 @@ fn types_of<'a>(node: &'a PhysNode) -> Vec<&'a DataType> { #[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 stack = vec![plan.root()]; while let Some(node) = stack.pop() { constructs_of(node, &mut |c| out.extend(feature_of(c))); 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 915b38332..d0a8e983d 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 @@ -67,6 +67,11 @@ pub struct ExprEnv { pub query_start_micros: i64, #[prost(string, tag = "4")] pub user: ::prost::alloc::string::String, + /// 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 = "5")] + 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 f2b0b2cd7..7c0b89762 100644 --- a/crates/krishiv-plan-codec/tests/common/inventory.rs +++ b/crates/krishiv-plan-codec/tests/common/inventory.rs @@ -36,6 +36,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, } } @@ -898,5 +899,16 @@ pub(crate) fn cases() -> Vec<(String, PhysicalPlan)> { .collect(); out.push(("expressions".to_owned(), plan_of(expressions()))); out.push(("nested_types".to_owned(), plan_of(nested_types()))); + 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) +} 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 0000000000000000000000000000000000000000..a58d2fb8cf187e4e7237ce97a2358a9d30868b67 GIT binary patch literal 352 zcmZWiF;2rk5S(+2eF}(JQ3@-fu&59vFQBHRL`cpFyNGbGC7Z$>C3F-#fDiBl3M8Jx zAC8%G8pNz-_ExvEV-K=q9W8PG8XW??Aiy+ya-*A(3h}; zD5%7c1NrvXm+FRKdCBfG<95w-Wd3WGKfU;$&yV-yG<6TI8T;YP+^lx4 UEAQ*Etm^8qE4#MY-i;gc3l)1N(EtDd literal 0 HcmV?d00001 diff --git a/crates/krishiv-plan-codec/tests/roundtrip.rs b/crates/krishiv-plan-codec/tests/roundtrip.rs index 902444870..e2d5747ab 100644 --- a/crates/krishiv-plan-codec/tests/roundtrip.rs +++ b/crates/krishiv-plan-codec/tests/roundtrip.rs @@ -293,7 +293,7 @@ fn readers_that_predate_features_still_refuse_what_they_cannot_read() { "window_ranking" | "window_aggregates" => 4, n if n.starts_with("expand") => 5, // A feature added after the freeze: above every frozen version. - "window_group_limit" | "nested_types" => 6, + "window_group_limit" | "nested_types" | "map_key_dedup_policy" => 6, n if n.starts_with("hash_join_right") => POST_MIGRATION_READER_VERSION, "window_frames" | "window_offset_values" => POST_MIGRATION_READER_VERSION, _ => MIN_READER_VERSION, diff --git a/crates/krishiv-plan/src/analyzer/coerce.rs b/crates/krishiv-plan/src/analyzer/coerce.rs index 79db56aec..973767749 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 { @@ -851,6 +867,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 @@ -969,6 +988,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 { @@ -999,7 +1107,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 @@ -1015,6 +1125,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!( @@ -1277,6 +1394,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 3c579b781..1484bbb14 100644 --- a/crates/krishiv-plan/src/analyzer/exprs.rs +++ b/crates/krishiv-plan/src/analyzer/exprs.rs @@ -10,10 +10,11 @@ use krishiv_common::error::{ CannotResolveDataframeColumn, CannotResolveStarExpand, DatatypeMismatchBinaryOpDiffTypes, DatatypeMismatchBinaryOpWrongType, DatatypeMismatchCastWithConfSuggestion, DatatypeMismatchCastWithFuncSuggestion, DatatypeMismatchCastWithoutSuggestion, + DatatypeMismatchCreateMapKeyDiffTypes, DatatypeMismatchCreateMapValueDiffTypes, DatatypeMismatchDataDiffTypes, DatatypeMismatchInSubqueryDataTypeMismatch, DatatypeMismatchInSubqueryLengthMismatch, DatatypeMismatchInvalidOrderingType, - DatatypeMismatchUnexpectedInputType, ExceptOverlappingColumns, - InvalidAggregateFilterNotBoolean, InvalidExtractBaseFieldType, + DatatypeMismatchMapConcatDiffTypes, DatatypeMismatchUnexpectedInputType, + ExceptOverlappingColumns, InvalidAggregateFilterNotBoolean, InvalidExtractBaseFieldType, InvalidSubqueryExpressionScalarSubqueryReturnMoreThanOneOutputColumn, InvalidUsageOfStarOrRegex, KrishivError, KrishivUnsupportedFeature, NestedAggregateFunction, UnresolvedColumnWithSuggestion, UnresolvedColumnWithoutSuggestion, UnresolvedRoutine, @@ -25,7 +26,7 @@ use twox_hash::XxHash3_128; use super::analytics::GroupingFn; use super::bind::{addr, same, unsupported}; 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, Rel, Resolver}; use super::{AnalysisError, ArgType, CallTypes, Constant, FunctionEntry, FunctionLookup, Inputs}; @@ -1257,7 +1258,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()) } @@ -1866,6 +1872,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 138839d46..ba53e6422 100644 --- a/crates/krishiv-plan/src/analyzer/mod.rs +++ b/crates/krishiv-plan/src/analyzer/mod.rs @@ -127,6 +127,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 '...'` @@ -151,6 +154,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), @@ -160,7 +164,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", @@ -169,6 +173,7 @@ impl ResolutionConf { "spark.sql.lateralColumnAlias.enableImplicitResolution", "spark.sql.decimalOperations.allowPrecisionLoss", "spark.sql.runSQLOnFiles", + "spark.sql.mapKeyDedupPolicy", "spark.sql.timestampType", "spark.sql.session.timeZone", ]; @@ -200,9 +205,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), }, diff --git a/crates/krishiv-session/tests/datetime_calendar.rs b/crates/krishiv-session/tests/datetime_calendar.rs index d9ab61632..1bdb2c057 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, 40, "{report}"); + assert_eq!(tally.normalized_months_between, 44, "{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(), - 20, + 24, ), ("cast of invalid UTF-8 bytes to a string".to_owned(), 23), ("no recorded rows".to_owned(), 62), @@ -312,7 +312,6 @@ fn expected_not_run() -> BTreeMap { ("unsupported: TIME literals".to_owned(), 6), ("unsupported: function DATE".to_owned(), 4), ("unsupported: function array".to_owned(), 74), - ("unsupported: function map".to_owned(), 74), ("unsupported: function named_struct".to_owned(), 74), ( "unsupported: the function convert_timezone (it has no binding for these arguments: a region time zone)" diff --git a/proto/krishiv/plan/v1/plan.proto b/proto/krishiv/plan/v1/plan.proto index 44412ebba..91d92575c 100644 --- a/proto/krishiv/plan/v1/plan.proto +++ b/proto/krishiv/plan/v1/plan.proto @@ -74,6 +74,10 @@ message ExprEnv { optional sint32 zone = 2; sint64 query_start_micros = 3; string user = 4; + // 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 = 5; } message ExplainNode { diff --git a/python/krishiv/sql/_generated_functions.py b/python/krishiv/sql/_generated_functions.py index fadef4b1e..569ea7d76 100644 --- a/python/krishiv/sql/_generated_functions.py +++ b/python/krishiv/sql/_generated_functions.py @@ -55,6 +55,7 @@ "cosh", "cot", "crc32", + "create_map", "csc", "cume_dist", "curdate", @@ -113,6 +114,13 @@ "lpad", "ltrim", "make_date", + "map_concat", + "map_contains_key", + "map_entries", + "map_from_arrays", + "map_from_entries", + "map_keys", + "map_values", "max", "md5", "mean", @@ -171,6 +179,7 @@ "sinh", "sqrt", "startswith", + "str_to_map", "substr", "substring", "sum", @@ -354,6 +363,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")) @@ -646,6 +660,41 @@ def make_date(year: ColumnOrName, month: ColumnOrName, day: ColumnOrName) -> Col return _call("make_date", _named(year, "year"), _named(month, "month"), _named(day, "day")) +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 max(col: ColumnOrName) -> Column: """Calls the registry function ``max``.""" return _call("max", _named(col, "col")) @@ -940,6 +989,18 @@ def startswith(str: ColumnOrName, prefix: ColumnOrName) -> Column: return _call("startswith", _named(str, "str"), _named(prefix, "prefix")) +def str_to_map( + text: ColumnOrName, pairDelim: ColumnOrName | None = None, keyValueDelim: ColumnOrName | None = None +) -> Column: + """Calls the registry function ``str_to_map``.""" + return _call( + "str_to_map", + _named(text, "text"), + *_opt(_named, pairDelim, "pairDelim"), + *_opt(_named, keyValueDelim, "keyValueDelim"), + ) + + def substr(str: ColumnOrName, pos: ColumnOrName, len: ColumnOrName | None = None) -> Column: """Calls the registry function ``substr``.""" return _call("substr", _named(str, "str"), _named(pos, "pos"), *_opt(_named, len, "len")) diff --git a/python/krishiv/sql/_generated_functions.pyi b/python/krishiv/sql/_generated_functions.pyi index bfa34d37b..495e92ddc 100644 --- a/python/krishiv/sql/_generated_functions.pyi +++ b/python/krishiv/sql/_generated_functions.pyi @@ -36,6 +36,7 @@ __all__ = [ "cosh", "cot", "crc32", + "create_map", "csc", "cume_dist", "curdate", @@ -94,6 +95,13 @@ __all__ = [ "lpad", "ltrim", "make_date", + "map_concat", + "map_contains_key", + "map_entries", + "map_from_arrays", + "map_from_entries", + "map_keys", + "map_values", "max", "md5", "mean", @@ -152,6 +160,7 @@ __all__ = [ "sinh", "sqrt", "startswith", + "str_to_map", "substr", "substring", "sum", @@ -213,6 +222,7 @@ def cos(col: ColumnOrName) -> Column: ... def cosh(col: ColumnOrName) -> Column: ... def cot(col: 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: ... @@ -271,6 +281,13 @@ def lower(col: ColumnOrName) -> Column: ... 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 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 max(col: ColumnOrName) -> Column: ... def md5(col: ColumnOrName) -> Column: ... def mean(col: ColumnOrName) -> Column: ... @@ -329,6 +346,9 @@ def sin(col: ColumnOrName) -> Column: ... def sinh(col: ColumnOrName) -> Column: ... def sqrt(col: ColumnOrName) -> Column: ... def startswith(str: ColumnOrName, prefix: ColumnOrName) -> Column: ... +def str_to_map( + text: ColumnOrName, pairDelim: ColumnOrName | None = None, keyValueDelim: ColumnOrName | None = None +) -> Column: ... def substr(str: ColumnOrName, pos: ColumnOrName, len: ColumnOrName | None = None) -> Column: ... def substring(str: ColumnOrName, pos: ColumnOrName | int, len: ColumnOrName | int) -> Column: ... def sum(col: ColumnOrName) -> Column: ... diff --git a/python/tests/_pyspark_signatures.py b/python/tests/_pyspark_signatures.py index 4ec4722d4..d5ce65dd6 100644 --- a/python/tests/_pyspark_signatures.py +++ b/python/tests/_pyspark_signatures.py @@ -47,6 +47,7 @@ "countDistinct": "col, *cols", "count_distinct": "col, *cols", "crc32": "col", + "create_map": "*cols", "csc": "col", "cume_dist": "", "curdate": "", @@ -109,6 +110,13 @@ "lpad": "col, len, pad", "ltrim": "col, trim=None", "make_date": "year, month, day", + "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", "max": "col", "md5": "col", "mean": "col", @@ -167,6 +175,7 @@ "sinh": "col", "sqrt": "col", "startswith": "str, prefix", + "str_to_map": "text, pairDelim=None, keyValueDelim=None", "substr": "str, pos, len=None", "substring": "str, pos, len", "sum": "col", diff --git a/python/tests/test_generated_functions.py b/python/tests/test_generated_functions.py index a2d51ecc0..8a29244c7 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 7df1f0f43..e495e2ae5 100644 --- a/tests/fixtures/analysis/registry-matrix/%26.json +++ b/tests/fixtures/analysis/registry-matrix/%26.json @@ -16,14 +16,6 @@ "id": "e331b4ed3e3/ansi_off", "reason": "SELECT (named_struct('a', 1, 'b', 'x')) & 5 | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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" @@ -48,14 +40,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": "&#c2f3c9f79da5/ansi_on", "reason": "SELECT (array(1, 2)) & 5 | KRISHIV_UNSUPPORTED_FEATURE: function array 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 fc7c47131..b68d10886 100644 --- a/tests/fixtures/analysis/registry-matrix/%3C%3C.json +++ b/tests/fixtures/analysis/registry-matrix/%3C%3C.json @@ -56,14 +56,6 @@ "id": "<<#83a6d37169a0/ansi_off", "reason": "SELECT (array(1, 2)) << 1 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "<<#b68d0e5fe063/ansi_on", - "reason": "SELECT 2 << (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "<<#b68d0e5fe063/ansi_off", - "reason": "SELECT 2 << (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "<<#c2978426938d/ansi_on", "reason": "SELECT (named_struct('a', 1, 'b', 'x')) << 1 | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -71,14 +63,6 @@ { "id": "<<#c2978426938d/ansi_off", "reason": "SELECT (named_struct('a', 1, 'b', 'x')) << 1 | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 e987e9cc5..a01e39013 100644 --- a/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json +++ b/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json @@ -32,14 +32,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 f551bf684..3b9a5d361 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 23242bcad..492d48c05 100644 --- a/tests/fixtures/analysis/registry-matrix/%5E.json +++ b/tests/fixtures/analysis/registry-matrix/%5E.json @@ -56,14 +56,6 @@ "id": "^#895a1c0297e8/ansi_off", "reason": "SELECT 3 ^ (named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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" @@ -71,14 +63,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 16cc7ced2..1beade1ce 100644 --- a/tests/fixtures/analysis/registry-matrix/%7C.json +++ b/tests/fixtures/analysis/registry-matrix/%7C.json @@ -63,22 +63,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 7028bdda9..8a8589b0e 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 57ced4942..fd1600b73 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#482fd6fb3fb5/ansi_on", "reason": "SELECT abs(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/acos.json b/tests/fixtures/analysis/registry-matrix/acos.json index ab31cfb4c..38cc2ae4f 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#87281b46e804/ansi_on", "reason": "SELECT acos(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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 d1a875267..8fa530be8 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#5a9d77ca8ad6/ansi_on", "reason": "SELECT acosh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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 be37ab20a..6b17a0539 100644 --- a/tests/fixtures/analysis/registry-matrix/add_months.json +++ b/tests/fixtures/analysis/registry-matrix/add_months.json @@ -8,14 +8,6 @@ "id": "add_months#1e08d6e1ace9/ansi_off", "reason": "SELECT add_months(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "add_months#22590bd13694/ansi_on", - "reason": "SELECT add_months('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" @@ -32,14 +24,6 @@ "id": "add_months#2e88092bbf13/ansi_off", "reason": "SELECT add_months('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "add_months#59aa9c148f08/ansi_on", - "reason": "SELECT add_months(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 e9e2879b6..7393324b7 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#94942fcbfe3e/ansi_on", "reason": "SELECT any_value(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" diff --git a/tests/fixtures/analysis/registry-matrix/asin.json b/tests/fixtures/analysis/registry-matrix/asin.json index bca3af4d1..cc2bc5b07 100644 --- a/tests/fixtures/analysis/registry-matrix/asin.json +++ b/tests/fixtures/analysis/registry-matrix/asin.json @@ -24,14 +24,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" - }, { "id": "asin#c049095f4686/ansi_on", "reason": "SELECT asin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/asinh.json b/tests/fixtures/analysis/registry-matrix/asinh.json index bf15c4236..4b55cec9c 100644 --- a/tests/fixtures/analysis/registry-matrix/asinh.json +++ b/tests/fixtures/analysis/registry-matrix/asinh.json @@ -16,14 +16,6 @@ "id": "asinh#65a403e1a21d/ansi_off", "reason": "SELECT asinh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "asinh#68bed1327e2a/ansi_on", - "reason": "SELECT asinh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 3e27eb0b3..37ec46e0f 100644 --- a/tests/fixtures/analysis/registry-matrix/assert_true.json +++ b/tests/fixtures/analysis/registry-matrix/assert_true.json @@ -16,14 +16,6 @@ "id": "assert_true#6b4725569cc4/ansi_off", "reason": "SELECT assert_true(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 37bcf8e7d..8ff945adb 100644 --- a/tests/fixtures/analysis/registry-matrix/atan.json +++ b/tests/fixtures/analysis/registry-matrix/atan.json @@ -24,14 +24,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" - }, { "id": "atan#f34317d2890d/ansi_on", "reason": "SELECT atan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/atan2.json b/tests/fixtures/analysis/registry-matrix/atan2.json index d6c7192d2..822397468 100644 --- a/tests/fixtures/analysis/registry-matrix/atan2.json +++ b/tests/fixtures/analysis/registry-matrix/atan2.json @@ -48,14 +48,6 @@ "id": "atan2#7692bbe02cfb/ansi_off", "reason": "SELECT atan2(named_struct('a', 1, 'b', 'x'), 0) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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" @@ -64,14 +56,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" - }, { "id": "atan2#ead386e08f1b/ansi_on", "reason": "SELECT atan2(0, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/atanh.json b/tests/fixtures/analysis/registry-matrix/atanh.json index 9c8130ab9..2ac4373bd 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#48c6a42b6065/ansi_on", "reason": "SELECT atanh(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/bin.json b/tests/fixtures/analysis/registry-matrix/bin.json index afe4e4308..d492dca80 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#7dbeeeda8d39/ansi_on", "reason": "SELECT bin(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 5e33ec31c..f4cb68538 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#b19032ce1e5a/ansi_on", "reason": "SELECT bit_count(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 b61eb7a52..06577e9f7 100644 --- a/tests/fixtures/analysis/registry-matrix/bit_get.json +++ b/tests/fixtures/analysis/registry-matrix/bit_get.json @@ -48,14 +48,6 @@ "id": "bit_get#8c299b6b019a/ansi_off", "reason": "SELECT bit_get(named_struct('a', 1, 'b', 'x'), 0) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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#a304d611b3ac/ansi_on", "reason": "SELECT bit_get(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +56,6 @@ "id": "bit_get#a304d611b3ac/ansi_off", "reason": "SELECT bit_get(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "bit_get#ce44b5105527/ansi_on", - "reason": "SELECT bit_get(11, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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/bround.json b/tests/fixtures/analysis/registry-matrix/bround.json index f4d1971b8..ab0892cec 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#2dd9f9244d5b/ansi_on", "reason": "SELECT bround(named_struct('a', 1, 'b', 'x'), 0) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -71,14 +63,6 @@ { "id": "bround#b53e747128fc/ansi_off", "reason": "SELECT bround(2.5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bround#e536627ae66a/ansi_on", - "reason": "SELECT bround(2.5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 92e9ab492..99c6fcd1f 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#1043c6b8f7d4/ansi_on", "reason": "SELECT btrim(X'', encode('SL', 'utf-8')) | KRISHIV_UNSUPPORTED_FEATURE: function encode" @@ -104,14 +88,6 @@ "id": "btrim#71e5a8cb22b3/ansi_off", "reason": "SELECT btrim('SSparkSQLS', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "btrim#812b69ba8fda/ansi_on", - "reason": "SELECT btrim('SSparkSQLS', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#8919629c6f37/ansi_on", "reason": "SELECT btrim('SSparkSQLS', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/cbrt.json b/tests/fixtures/analysis/registry-matrix/cbrt.json index 953c55a64..a4198e3a8 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#9709bdf461bb/ansi_on", "reason": "SELECT cbrt(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 9db77cf58..7df42fa99 100644 --- a/tests/fixtures/analysis/registry-matrix/ceil.json +++ b/tests/fixtures/analysis/registry-matrix/ceil.json @@ -24,14 +24,6 @@ "id": "ceil#3ed3ac5ba694/ansi_off", "reason": "SELECT ceil(named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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" @@ -40,14 +32,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#68dccc710861/ansi_on", "reason": "SELECT ceil(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -111,14 +95,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 a79ebdf8b..6116cbb96 100644 --- a/tests/fixtures/analysis/registry-matrix/ceiling.json +++ b/tests/fixtures/analysis/registry-matrix/ceiling.json @@ -40,14 +40,6 @@ "id": "ceiling#4d0147cd7a92/ansi_off", "reason": "SELECT ceiling(3.1411, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has NON_FOLDABLE_ARGUMENT" }, - { - "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#63e6ed7b8d9f/ansi_on", "reason": "SELECT ceiling(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -72,14 +64,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" @@ -96,14 +80,6 @@ "id": "ceiling#edc642c068e1/ansi_off", "reason": "SELECT ceiling(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT" }, - { - "id": "ceiling#f4a8508a15c7/ansi_on", - "reason": "SELECT ceiling(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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_length.json b/tests/fixtures/analysis/registry-matrix/char_length.json index 8b3674002..f2e72563b 100644 --- a/tests/fixtures/analysis/registry-matrix/char_length.json +++ b/tests/fixtures/analysis/registry-matrix/char_length.json @@ -16,14 +16,6 @@ "id": "char_length#3e6537335dd1/ansi_off", "reason": "SELECT char_length(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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#5ae2fd4ad7df/ansi_on", "reason": "SELECT char_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/character_length.json b/tests/fixtures/analysis/registry-matrix/character_length.json index e10da22fb..e1d4bc8dc 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/coalesce.json b/tests/fixtures/analysis/registry-matrix/coalesce.json index 84c9d8037..359d23865 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#180ee04bc98b/ansi_on", "reason": "SELECT coalesce(NULL, 1, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -32,22 +24,6 @@ "id": "coalesce#3297ad75dfb5/ansi_off", "reason": "SELECT coalesce(array(1, 2), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "coalesce#58920259386f/ansi_on", - "reason": "SELECT coalesce(map('a', 1), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "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/contains.json b/tests/fixtures/analysis/registry-matrix/contains.json index 3be7bdb8d..e51d4dda4 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" @@ -71,14 +63,6 @@ { "id": "contains#dcebc7ca8e0a/ansi_off", "reason": "SELECT contains(named_struct('a', 1, 'b', 'x'), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 7a225c22e..d127e0070 100644 --- a/tests/fixtures/analysis/registry-matrix/conv.json +++ b/tests/fixtures/analysis/registry-matrix/conv.json @@ -8,14 +8,6 @@ "id": "conv#0d4fe942fe9d/ansi_off", "reason": "SELECT conv('100', 2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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#308fccd7a450/ansi_on", "reason": "SELECT conv(named_struct('a', 1, 'b', 'x'), 2, 10) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +56,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" @@ -104,14 +88,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" - }, { "id": "conv#ec214d3068bf/ansi_on", "reason": "SELECT conv('100', 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/convert_timezone.json b/tests/fixtures/analysis/registry-matrix/convert_timezone.json index 099400206..306f51b00 100644 --- a/tests/fixtures/analysis/registry-matrix/convert_timezone.json +++ b/tests/fixtures/analysis/registry-matrix/convert_timezone.json @@ -96,14 +96,6 @@ "id": "convert_timezone#51a54a73ab9d/ansi_off", "reason": "SELECT convert_timezone('Europe/Brussels', array(1, 2), timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "convert_timezone#5a82d191b61f/ansi_on", - "reason": "SELECT convert_timezone(map('a', 1), timestamp_ntz'2021-12-05 15:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" @@ -112,38 +104,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 049070043..7d5307581 100644 --- a/tests/fixtures/analysis/registry-matrix/cos.json +++ b/tests/fixtures/analysis/registry-matrix/cos.json @@ -24,14 +24,6 @@ "id": "cos#581fb00920dd/ansi_off", "reason": "SELECT cos(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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" - }, { "id": "cos#d8a37c57177c/ansi_on", "reason": "SELECT cos(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/cosh.json b/tests/fixtures/analysis/registry-matrix/cosh.json index 556ceb171..f78da5339 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#237a92894fe4/ansi_on", "reason": "SELECT cosh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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 3bf3bd89d..50426397c 100644 --- a/tests/fixtures/analysis/registry-matrix/cot.json +++ b/tests/fixtures/analysis/registry-matrix/cot.json @@ -16,14 +16,6 @@ "id": "cot#c525cd60d93f/ansi_off", "reason": "SELECT cot(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "cot#d332d357b677/ansi_on", - "reason": "SELECT cot(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#daf5910e0379/ansi_on", "reason": "SELECT cot(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 97556977e..15de9af87 100644 --- a/tests/fixtures/analysis/registry-matrix/crc32.json +++ b/tests/fixtures/analysis/registry-matrix/crc32.json @@ -24,14 +24,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" - }, { "id": "crc32#7c5f442029dc/ansi_on", "reason": "SELECT crc32(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/csc.json b/tests/fixtures/analysis/registry-matrix/csc.json index 0a33357fd..163bb4541 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 66479b9fe..71f6b610d 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 cc36a0a71..1ee6f7fa4 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#06d2c47693d1/ansi_on", "reason": "SELECT date_diff(array(1, 2), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,6 @@ "id": "date_diff#7612d4b942ab/ansi_off", "reason": "SELECT date_diff('2009-07-31', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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#d030945d4990/ansi_on", "reason": "SELECT date_diff(named_struct('a', 1, 'b', 'x'), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/date_part.json b/tests/fixtures/analysis/registry-matrix/date_part.json index aec55560d..b1d64c2c2 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') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 c91c36d5d..76180ff5f 100644 --- a/tests/fixtures/analysis/registry-matrix/date_sub.json +++ b/tests/fixtures/analysis/registry-matrix/date_sub.json @@ -32,14 +32,6 @@ "id": "date_sub#a24ef0a9b5b8/ansi_off", "reason": "SELECT date_sub(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_sub#adae19b649ad/ansi_on", - "reason": "SELECT date_sub(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" @@ -71,14 +63,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 a59f1f488..2c0fa7b7d 100644 --- a/tests/fixtures/analysis/registry-matrix/date_trunc.json +++ b/tests/fixtures/analysis/registry-matrix/date_trunc.json @@ -32,14 +32,6 @@ "id": "date_trunc#939c9dd369ab/ansi_off", "reason": "SELECT date_trunc(array(1, 2), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_trunc#ab8944d5b81e/ansi_on", - "reason": "SELECT date_trunc(map('a', 1), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_trunc#ab8944d5b81e/ansi_off", - "reason": "SELECT date_trunc(map('a', 1), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_trunc#b60f1d3d4024/ansi_on", "reason": "SELECT date_trunc('YEAR', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,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 df3e78ed3..a4bb1af1d 100644 --- a/tests/fixtures/analysis/registry-matrix/dateadd.json +++ b/tests/fixtures/analysis/registry-matrix/dateadd.json @@ -63,22 +63,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 9a053b465..fe4d41c25 100644 --- a/tests/fixtures/analysis/registry-matrix/datediff.json +++ b/tests/fixtures/analysis/registry-matrix/datediff.json @@ -16,14 +16,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#37853cc4b2c4/ansi_on", "reason": "SELECT datediff(named_struct('a', 1, 'b', 'x'), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "datediff#37853cc4b2c4/ansi_off", "reason": "SELECT datediff(named_struct('a', 1, 'b', 'x'), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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 74e6d3a61..9e012785d 100644 --- a/tests/fixtures/analysis/registry-matrix/day.json +++ b/tests/fixtures/analysis/registry-matrix/day.json @@ -24,14 +24,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 0bfa0d35c..477b49a8b 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 889196588..b349e20cd 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#039eeb4f3b46/ansi_on", "reason": "SELECT dayofmonth(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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 e91adbb75..235822d53 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 239018053..6fb8ee7cb 100644 --- a/tests/fixtures/analysis/registry-matrix/dayofyear.json +++ b/tests/fixtures/analysis/registry-matrix/dayofyear.json @@ -8,14 +8,6 @@ "id": "dayofyear#6b1828e51769/ansi_off", "reason": "SELECT dayofyear(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "dayofyear#8545d9aa0c51/ansi_on", - "reason": "SELECT dayofyear(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#8ba0b35165ce/ansi_on", "reason": "SELECT dayofyear(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/degrees.json b/tests/fixtures/analysis/registry-matrix/degrees.json index 9d448603d..083a22d19 100644 --- a/tests/fixtures/analysis/registry-matrix/degrees.json +++ b/tests/fixtures/analysis/registry-matrix/degrees.json @@ -8,14 +8,6 @@ "id": "degrees#0f5e2f47c537/ansi_off", "reason": "SELECT degrees(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "degrees#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#a6a490bd9aef/ansi_on", "reason": "SELECT degrees(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/endswith.json b/tests/fixtures/analysis/registry-matrix/endswith.json index 493e63be8..8c4aadb37 100644 --- a/tests/fixtures/analysis/registry-matrix/endswith.json +++ b/tests/fixtures/analysis/registry-matrix/endswith.json @@ -8,14 +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#3d0b927b5d71/ansi_on", "reason": "SELECT endswith('Spark SQL', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "endswith#4e2ec4ba4758/ansi_off", "reason": "SELECT endswith(named_struct('a', 1, 'b', 'x'), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 c3639d497..5b927bb2f 100644 --- a/tests/fixtures/analysis/registry-matrix/equal_null.json +++ b/tests/fixtures/analysis/registry-matrix/equal_null.json @@ -52,14 +52,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" @@ -84,14 +76,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 3df99ed6a..d79b491f1 100644 --- a/tests/fixtures/analysis/registry-matrix/exp.json +++ b/tests/fixtures/analysis/registry-matrix/exp.json @@ -31,14 +31,6 @@ { "id": "exp#eec810ac174b/ansi_off", "reason": "SELECT exp(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "exp#f67051cd986a/ansi_on", - "reason": "SELECT exp(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 4378b0dde..d1d914f7d 100644 --- a/tests/fixtures/analysis/registry-matrix/expm1.json +++ b/tests/fixtures/analysis/registry-matrix/expm1.json @@ -16,14 +16,6 @@ "id": "expm1#235cf212eb44/ansi_off", "reason": "SELECT expm1(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "expm1#34c7be4db61b/ansi_on", - "reason": "SELECT expm1(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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/first.json b/tests/fixtures/analysis/registry-matrix/first.json index 4603657b1..619be53f4 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 f6feaae8a..116f27ed7 100644 --- a/tests/fixtures/analysis/registry-matrix/first_value.json +++ b/tests/fixtures/analysis/registry-matrix/first_value.json @@ -31,14 +31,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 a2fe09dde..0d0516247 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#2fd8abd3b4d5/ansi_on", "reason": "SELECT floor(3.1411, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has NON_FOLDABLE_ARGUMENT" @@ -40,14 +32,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" @@ -111,14 +95,6 @@ { "id": "floor#eafebbc04618/ansi_off", "reason": "SELECT floor(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "floor#f7b36fd3e154/ansi_on", - "reason": "SELECT floor(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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/format_number.json b/tests/fixtures/analysis/registry-matrix/format_number.json index 7beb56179..ca558f6fd 100644 --- a/tests/fixtures/analysis/registry-matrix/format_number.json +++ b/tests/fixtures/analysis/registry-matrix/format_number.json @@ -16,14 +16,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" @@ -71,14 +63,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 768cc3769..5e871b2a1 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" @@ -48,14 +40,6 @@ "id": "from_utc_timestamp#7a2f639bdf28/ansi_off", "reason": "SELECT from_utc_timestamp(array(1, 2), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "from_utc_timestamp#83b5c806c510/ansi_on", - "reason": "SELECT from_utc_timestamp('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "from_utc_timestamp#83b5c806c510/ansi_off", - "reason": "SELECT from_utc_timestamp('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "from_utc_timestamp#94ac3581dfd4/ansi_on", "reason": "SELECT from_utc_timestamp('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/getbit.json b/tests/fixtures/analysis/registry-matrix/getbit.json index aa8ffb768..21c4301da 100644 --- a/tests/fixtures/analysis/registry-matrix/getbit.json +++ b/tests/fixtures/analysis/registry-matrix/getbit.json @@ -24,14 +24,6 @@ "id": "getbit#34593c66c6d1/ansi_off", "reason": "SELECT getbit(11, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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#699ba6576802/ansi_on", "reason": "SELECT getbit(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,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#9419dda3fafc/ansi_on", "reason": "SELECT getbit(11, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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 73d57b7ac..9f62b29a2 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" @@ -104,14 +96,6 @@ "id": "greatest#80f86bb7e057/ansi_off", "reason": "SELECT greatest(10, 9, 2, 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "greatest#824668970bd6/ansi_on", - "reason": "SELECT greatest(map('a', 1), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "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#84abe3fe1684/ansi_on", "reason": "SELECT greatest(10, 9, 2, named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -152,14 +136,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#b51e4d0651cf/ansi_on", "reason": "SELECT greatest(10, 9, array(1, 2), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -176,14 +152,6 @@ "id": "greatest#b9d968efd344/ansi_off", "reason": "SELECT greatest(named_struct('a', 1, 'b', 'x'), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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" @@ -191,14 +159,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 5bb40c20c..555f3a23f 100644 --- a/tests/fixtures/analysis/registry-matrix/hash.json +++ b/tests/fixtures/analysis/registry-matrix/hash.json @@ -162,11 +162,11 @@ }, { "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#5556de897838/ansi_on", @@ -218,11 +218,11 @@ }, { "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) | KRISHIV_UNSUPPORTED_FEATURE: function array 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) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "hash#7d1796847464/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/hex.json b/tests/fixtures/analysis/registry-matrix/hex.json index 6ee27a333..0f9fc379e 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#2d96fe39d5ac/ansi_on", "reason": "SELECT hex(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/hour.json b/tests/fixtures/analysis/registry-matrix/hour.json index f52af9c66..542933088 100644 --- a/tests/fixtures/analysis/registry-matrix/hour.json +++ b/tests/fixtures/analysis/registry-matrix/hour.json @@ -24,14 +24,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 ec6498cc4..afc41c01e 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#5ef785b91579/ansi_on", "reason": "SELECT hypot(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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 12e583a31..11b92bf97 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" @@ -111,14 +95,6 @@ { "id": "if#da00eb044050/ansi_off", "reason": "SELECT if(1 < 2, array(1, 2), 'b') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "if#ec0d1d6bf87a/ansi_on", - "reason": "SELECT if(map('a', 1), 'a', 'b') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 68a219829..d02df1461 100644 --- a/tests/fixtures/analysis/registry-matrix/ifnull.json +++ b/tests/fixtures/analysis/registry-matrix/ifnull.json @@ -58,11 +58,11 @@ }, { "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" + "reason": "SELECT ifnull(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array 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" + "reason": "SELECT ifnull(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "ifnull#679800a7c1ba/ansi_on", @@ -192,14 +192,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#d840be61918f/ansi_on", "reason": "SELECT ifnull(array(1, 2), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array" diff --git a/tests/fixtures/analysis/registry-matrix/isnan.json b/tests/fixtures/analysis/registry-matrix/isnan.json index 5076e1454..f19742bed 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#5ce0c7195c83/ansi_on", "reason": "SELECT isnan(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 9463d36a3..c1a2355cd 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 7c65e966f..fc35e16ca 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#3b045f12ca67/ansi_on", "reason": "SELECT isnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" diff --git a/tests/fixtures/analysis/registry-matrix/last.json b/tests/fixtures/analysis/registry-matrix/last.json index 9b48370af..53978335d 100644 --- a/tests/fixtures/analysis/registry-matrix/last.json +++ b/tests/fixtures/analysis/registry-matrix/last.json @@ -24,14 +24,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" - }, { "id": "last#903f35baac68/ansi_on", "reason": "SELECT last(col, named_struct('a', 1, 'b', 'x')) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has _LEGACY_ERROR_TEMP_1210" diff --git a/tests/fixtures/analysis/registry-matrix/last_day.json b/tests/fixtures/analysis/registry-matrix/last_day.json index 02fc7d297..10ca265bb 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#93f4e80f80b9/ansi_on", "reason": "SELECT last_day(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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 00475416b..8206f856d 100644 --- a/tests/fixtures/analysis/registry-matrix/last_value.json +++ b/tests/fixtures/analysis/registry-matrix/last_value.json @@ -8,14 +8,6 @@ "id": "last_value#2b628baff52d/ansi_off", "reason": "SELECT last_value(col, array(1, 2)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" }, - { - "id": "last_value#59116f565aa7/ansi_on", - "reason": "SELECT last_value(col, map('a', 1)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "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 464c52b59..0c4daf192 100644 --- a/tests/fixtures/analysis/registry-matrix/lcase.json +++ b/tests/fixtures/analysis/registry-matrix/lcase.json @@ -16,14 +16,6 @@ "id": "lcase#77b7ee7da5a4/ansi_off", "reason": "SELECT lcase(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "lcase#a43c0260bd5e/ansi_on", - "reason": "SELECT lcase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 64662ce00..15ed64add 100644 --- a/tests/fixtures/analysis/registry-matrix/least.json +++ b/tests/fixtures/analysis/registry-matrix/least.json @@ -8,14 +8,6 @@ "id": "least#0cf7212d2d65/ansi_off", "reason": "SELECT least(10, named_struct('a', 1, 'b', 'x'), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "least#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" @@ -56,14 +48,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" @@ -72,14 +56,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#6dbc49b61cae/ansi_on", "reason": "SELECT least(10, 9, 2, named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -160,22 +136,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#ee82fb8da979/ansi_on", "reason": "SELECT least(10, 9, 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/length.json b/tests/fixtures/analysis/registry-matrix/length.json index dc5cc0307..1b99413de 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#55ae664eebe8/ansi_on", "reason": "SELECT length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/ln.json b/tests/fixtures/analysis/registry-matrix/ln.json index c95fec762..7c483974a 100644 --- a/tests/fixtures/analysis/registry-matrix/ln.json +++ b/tests/fixtures/analysis/registry-matrix/ln.json @@ -31,14 +31,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/log.json b/tests/fixtures/analysis/registry-matrix/log.json index 203c106b4..89d5e9c80 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#5c08d869324e/ansi_on", "reason": "SELECT log(10, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -40,14 +32,6 @@ "id": "log#8133712d84fb/ansi_off", "reason": "SELECT log(named_struct('a', 1, 'b', 'x'), 100) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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#97df9415f277/ansi_on", "reason": "SELECT log(array(1, 2), 100) | KRISHIV_UNSUPPORTED_FEATURE: function array 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 279c4947c..745b652af 100644 --- a/tests/fixtures/analysis/registry-matrix/log10.json +++ b/tests/fixtures/analysis/registry-matrix/log10.json @@ -24,14 +24,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 29769929a..b7d4d6700 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#406cb2466c70/ansi_on", "reason": "SELECT log1p(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 93ec70f6f..0c5b4f3f6 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#2a2c31c8341e/ansi_on", "reason": "SELECT log2(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/lower.json b/tests/fixtures/analysis/registry-matrix/lower.json index 9e9308f55..941c23597 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#3e7f165b4997/ansi_on", "reason": "SELECT lower(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/lpad.json b/tests/fixtures/analysis/registry-matrix/lpad.json index 727e618d2..3e73d9973 100644 --- a/tests/fixtures/analysis/registry-matrix/lpad.json +++ b/tests/fixtures/analysis/registry-matrix/lpad.json @@ -80,22 +80,6 @@ "id": "lpad#5b222c93b4c7/ansi_off", "reason": "SELECT lpad(named_struct('a', 1, 'b', 'x'), 5) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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#7fbbfc2d5d70/ansi_on", "reason": "SELECT lpad('hi', array(1, 2), '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -104,14 +88,6 @@ "id": "lpad#7fbbfc2d5d70/ansi_off", "reason": "SELECT lpad('hi', array(1, 2), '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "lpad#86f3021e158c/ansi_on", - "reason": "SELECT lpad(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" @@ -128,14 +104,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" @@ -176,14 +144,6 @@ "id": "lpad#edbd77fd8cb2/ansi_off", "reason": "SELECT lpad('hi', named_struct('a', 1, 'b', 'x'), '??') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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 7776e8985..dd5496672 100644 --- a/tests/fixtures/analysis/registry-matrix/ltrim.json +++ b/tests/fixtures/analysis/registry-matrix/ltrim.json @@ -24,14 +24,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" - }, { "id": "ltrim#bf0dac2666b9/ansi_on", "reason": "SELECT ltrim(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/make_date.json b/tests/fixtures/analysis/registry-matrix/make_date.json index 724e8a9c1..225bda690 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" @@ -48,14 +40,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#5dd9383be951/ansi_on", "reason": "SELECT make_date(2013, named_struct('a', 1, 'b', 'x'), 15) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +48,6 @@ "id": "make_date#5dd9383be951/ansi_off", "reason": "SELECT make_date(2013, named_struct('a', 1, 'b', 'x'), 15) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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#670b553cefcd/ansi_on", "reason": "SELECT make_date(2013, array(1, 2), 15) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/map.json b/tests/fixtures/analysis/registry-matrix/map.json new file mode 100644 index 000000000..d26c0743f --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map.json @@ -0,0 +1,134 @@ +{ + "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#2897abadce0d/ansi_on", + "reason": "SELECT map(1.0, '2', array(1, 2), '4') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#2897abadce0d/ansi_off", + "reason": "SELECT map(1.0, '2', array(1, 2), '4') | KRISHIV_UNSUPPORTED_FEATURE: function array 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#4093a0df4741/ansi_on", + "reason": "SELECT map(array(1, 2), '2', 3.0, '4') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#4093a0df4741/ansi_off", + "reason": "SELECT map(array(1, 2), '2', 3.0, '4') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#631c2dc341f0/ansi_on", + "reason": "SELECT map(1.0, '2', named_struct('a', 1, 'b', 'x'), '4') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#631c2dc341f0/ansi_off", + "reason": "SELECT map(1.0, '2', named_struct('a', 1, 'b', 'x'), '4') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#699668f72fbb/ansi_on", + "reason": "SELECT map(1.0, '2', 3.0, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "id": "map#699668f72fbb/ansi_off", + "reason": "SELECT map(1.0, '2', 3.0, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "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#71af2e5ab842/ansi_on", + "reason": "SELECT map(1.0, named_struct('a', 1, 'b', 'x'), 3.0, '4') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "id": "map#71af2e5ab842/ansi_off", + "reason": "SELECT map(1.0, named_struct('a', 1, 'b', 'x'), 3.0, '4') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "id": "map#8f4bedf919eb/ansi_on", + "reason": "SELECT map(1.0, '2', 3.0, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "id": "map#8f4bedf919eb/ansi_off", + "reason": "SELECT map(1.0, '2', 3.0, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "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#a5ac4539b2df/ansi_on", + "reason": "SELECT map(1.0, array(1, 2), 3.0, '4') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "id": "map#a5ac4539b2df/ansi_off", + "reason": "SELECT map(1.0, array(1, 2), 3.0, '4') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.CREATE_MAP_VALUE_DIFF_TYPES" + }, + { + "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" + }, + { + "id": "map#fc4adcf269b3/ansi_on", + "reason": "SELECT map(named_struct('a', 1, 'b', 'x'), '2', 3.0, '4') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + }, + { + "id": "map#fc4adcf269b3/ansi_off", + "reason": "SELECT map(named_struct('a', 1, 'b', 'x'), '2', 3.0, '4') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.CREATE_MAP_KEY_DIFF_TYPES" + } + ], + "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..14750872d --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_concat.json @@ -0,0 +1,70 @@ +{ + "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#9581dd8cd692/ansi_on", + "reason": "SELECT map_concat(map(1, 'a', 2, 'b'), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#9581dd8cd692/ansi_off", + "reason": "SELECT map_concat(map(1, 'a', 2, 'b'), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#a6b461959131/ansi_on", + "reason": "SELECT map_concat(named_struct('a', 1, 'b', 'x'), map(3, 'c')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#a6b461959131/ansi_off", + "reason": "SELECT map_concat(named_struct('a', 1, 'b', 'x'), map(3, 'c')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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#d63f5360f92c/ansi_on", + "reason": "SELECT map_concat(map(1, 'a', 2, 'b'), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#d63f5360f92c/ansi_off", + "reason": "SELECT map_concat(map(1, 'a', 2, 'b'), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#d70b848957b9/ansi_on", + "reason": "SELECT map_concat(array(1, 2), map(3, 'c')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.MAP_CONCAT_DIFF_TYPES" + }, + { + "id": "map_concat#d70b848957b9/ansi_off", + "reason": "SELECT map_concat(array(1, 2), map(3, 'c')) | KRISHIV_UNSUPPORTED_FEATURE: function array 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..092320f68 --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_contains_key.json @@ -0,0 +1,70 @@ +{ + "entries": [ + { + "id": "map_contains_key#1c4aa20e3cf1/ansi_on", + "reason": "SELECT map_contains_key(map(1, 'a', 2, 'b'), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#1c4aa20e3cf1/ansi_off", + "reason": "SELECT map_contains_key(map(1, 'a', 2, 'b'), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#7f4aaf7a7256/ansi_on", + "reason": "SELECT map_contains_key(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#7f4aaf7a7256/ansi_off", + "reason": "SELECT map_contains_key(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "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#bf0c4b07578a/ansi_on", + "reason": "SELECT map_contains_key(named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#bf0c4b07578a/ansi_off", + "reason": "SELECT map_contains_key(named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#cda8436dca74/ansi_on", + "reason": "SELECT map_contains_key(map(1, 'a', 2, 'b'), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.MAP_FUNCTION_DIFF_TYPES" + }, + { + "id": "map_contains_key#cda8436dca74/ansi_off", + "reason": "SELECT map_contains_key(map(1, 'a', 2, 'b'), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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..0c54d32e3 --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_entries.json @@ -0,0 +1,38 @@ +{ + "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" + }, + { + "id": "map_entries#3f809085e17d/ansi_on", + "reason": "SELECT map_entries(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_entries#3f809085e17d/ansi_off", + "reason": "SELECT map_entries(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_entries#e2c9d0ebe4d3/ansi_on", + "reason": "SELECT map_entries(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_entries#e2c9d0ebe4d3/ansi_off", + "reason": "SELECT map_entries(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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..019c3b580 --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_from_arrays.json @@ -0,0 +1,398 @@ +{ + "entries": [ + { + "id": "map_from_arrays#0660ff81c246/ansi_on", + "reason": "SELECT map_from_arrays(CAST(array(NULL) AS array), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#0660ff81c246/ansi_off", + "reason": "SELECT map_from_arrays(CAST(array(NULL) AS array), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "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#0f52360b7413/ansi_on", + "reason": "SELECT map_from_arrays(1L, array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#0f52360b7413/ansi_off", + "reason": "SELECT map_from_arrays(1L, array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#153e842e8344/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(1.5 AS DECIMAL(10,2))) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#153e842e8344/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(1.5 AS DECIMAL(10,2))) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#16042c3c1e00/ansi_on", + "reason": "SELECT map_from_arrays(CAST(1.5 AS DECIMAL(38,18)), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#16042c3c1e00/ansi_off", + "reason": "SELECT map_from_arrays(CAST(1.5 AS DECIMAL(38,18)), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array 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#20da05e965d1/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), 1.5D) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#20da05e965d1/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), 1.5D) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#2ff9af52f043/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), true) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#2ff9af52f043/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), true) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#30e74cfad197/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#30e74cfad197/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#35058531e4b2/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(1.5 AS FLOAT)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#35058531e4b2/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(1.5 AS FLOAT)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#3c125cef8745/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), X'01') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#3c125cef8745/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), X'01') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#48d5e64423bf/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), DATE'2024-02-29') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#48d5e64423bf/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), DATE'2024-02-29') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#4d7146d24166/ansi_on", + "reason": "SELECT map_from_arrays(NULL, array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#4d7146d24166/ansi_off", + "reason": "SELECT map_from_arrays(NULL, array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#5466eccac465/ansi_on", + "reason": "SELECT map_from_arrays('abc', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#5466eccac465/ansi_off", + "reason": "SELECT map_from_arrays('abc', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#56a22be11dd7/ansi_on", + "reason": "SELECT map_from_arrays(array(1, 2), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#56a22be11dd7/ansi_off", + "reason": "SELECT map_from_arrays(array(1, 2), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#56e99f81810c/ansi_on", + "reason": "SELECT map_from_arrays(CAST(array() AS array), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#56e99f81810c/ansi_off", + "reason": "SELECT map_from_arrays(CAST(array() AS array), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#5a97f84b0a0d/ansi_on", + "reason": "SELECT map_from_arrays(map('a', 1), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#5a97f84b0a0d/ansi_off", + "reason": "SELECT map_from_arrays(map('a', 1), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#5b8ab08cbe9a/ansi_on", + "reason": "SELECT map_from_arrays(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#5b8ab08cbe9a/ansi_off", + "reason": "SELECT map_from_arrays(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#5ee8c2f667e0/ansi_on", + "reason": "SELECT map_from_arrays(CAST(1.5 AS DECIMAL(10,2)), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#5ee8c2f667e0/ansi_off", + "reason": "SELECT map_from_arrays(CAST(1.5 AS DECIMAL(10,2)), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#5f2f539d5e7e/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(NULL AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#5f2f539d5e7e/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(NULL AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#61e13a4d7e06/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#61e13a4d7e06/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#7020aedb6468/ansi_on", + "reason": "SELECT map_from_arrays(DATE'2024-02-29', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#7020aedb6468/ansi_off", + "reason": "SELECT map_from_arrays(DATE'2024-02-29', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#752be3ca1fca/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), 'abc') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#752be3ca1fca/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), 'abc') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#7b9313bb2576/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(array(NULL) AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#7b9313bb2576/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(array(NULL) AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#7cd9c48b638c/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(array() AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#7cd9c48b638c/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(array() AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#7dd527c103ee/ansi_on", + "reason": "SELECT map_from_arrays(1.5D, array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#7dd527c103ee/ansi_off", + "reason": "SELECT map_from_arrays(1.5D, array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#7e2acb0d6b31/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#7e2acb0d6b31/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#8a30c5a49183/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), 1L) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#8a30c5a49183/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), 1L) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#8cea6f86e02d/ansi_on", + "reason": "SELECT map_from_arrays('1', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#8cea6f86e02d/ansi_off", + "reason": "SELECT map_from_arrays('1', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#9044d887d8a5/ansi_on", + "reason": "SELECT map_from_arrays(X'01', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#9044d887d8a5/ansi_off", + "reason": "SELECT map_from_arrays(X'01', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#905bf1a92b77/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(1 AS SMALLINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#905bf1a92b77/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(1 AS SMALLINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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#c6950d69494a/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#c6950d69494a/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#c9c3e0a8ca96/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#c9c3e0a8ca96/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array 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" + }, + { + "id": "map_from_arrays#cb7e551dd598/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#cb7e551dd598/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#cb8113c4a65d/ansi_on", + "reason": "SELECT map_from_arrays(CAST(1 AS TINYINT), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#cb8113c4a65d/ansi_off", + "reason": "SELECT map_from_arrays(CAST(1 AS TINYINT), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#d4db2f0ce5e1/ansi_on", + "reason": "SELECT map_from_arrays(CAST(NULL AS array), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#d4db2f0ce5e1/ansi_off", + "reason": "SELECT map_from_arrays(CAST(NULL AS array), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#d87efee035f8/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(1.5 AS DECIMAL(38,18))) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#d87efee035f8/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(1.5 AS DECIMAL(38,18))) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#df35cd412a32/ansi_on", + "reason": "SELECT map_from_arrays(CAST(1.5 AS FLOAT), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#df35cd412a32/ansi_off", + "reason": "SELECT map_from_arrays(CAST(1.5 AS FLOAT), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#e01f7212f12d/ansi_on", + "reason": "SELECT map_from_arrays(1, array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#e01f7212f12d/ansi_off", + "reason": "SELECT map_from_arrays(1, array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#e1258ccbf65f/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(1 AS TINYINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#e1258ccbf65f/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), CAST(1 AS TINYINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#e4e788aa552f/ansi_on", + "reason": "SELECT map_from_arrays(named_struct('a', 1, 'b', 'x'), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#e4e788aa552f/ansi_off", + "reason": "SELECT map_from_arrays(named_struct('a', 1, 'b', 'x'), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#e6f367131816/ansi_on", + "reason": "SELECT map_from_arrays(TIMESTAMP'2024-02-29 12:34:56.123456', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#e6f367131816/ansi_off", + "reason": "SELECT map_from_arrays(TIMESTAMP'2024-02-29 12:34:56.123456', array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#e78935093586/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#e78935093586/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#eb603fecb433/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#eb603fecb433/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#f054a9f8d148/ansi_on", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#f054a9f8d148/ansi_off", + "reason": "SELECT map_from_arrays(array(1.0, 3.0), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_arrays#f2805f23a533/ansi_on", + "reason": "SELECT map_from_arrays(true, array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#f2805f23a533/ansi_off", + "reason": "SELECT map_from_arrays(true, array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#fc351dbf6918/ansi_on", + "reason": "SELECT map_from_arrays(CAST(1 AS SMALLINT), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_arrays#fc351dbf6918/ansi_off", + "reason": "SELECT map_from_arrays(CAST(1 AS SMALLINT), array('2', '4')) | KRISHIV_UNSUPPORTED_FEATURE: function array 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..762780aaf --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_from_entries.json @@ -0,0 +1,62 @@ +{ + "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#4cc58b4820f5/ansi_on", + "reason": "SELECT map_from_entries(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_entries#4cc58b4820f5/ansi_off", + "reason": "SELECT map_from_entries(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_entries#4f13d79c03ee/ansi_on", + "reason": "SELECT map_from_entries(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_entries#4f13d79c03ee/ansi_off", + "reason": "SELECT map_from_entries(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_from_entries#664f361aaffa/ansi_on", + "reason": "SELECT map_from_entries(CAST(array(NULL) AS array>)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_entries#664f361aaffa/ansi_off", + "reason": "SELECT map_from_entries(CAST(array(NULL) AS array>)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_entries#7e5f03554384/ansi_on", + "reason": "SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b'))) | parse: KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + }, + { + "id": "map_from_entries#7e5f03554384/ansi_off", + "reason": "SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b'))) | parse: KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + }, + { + "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" + }, + { + "id": "map_from_entries#a9dd0f288b2a/ansi_on", + "reason": "SELECT map_from_entries(CAST(array() AS array>)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + }, + { + "id": "map_from_entries#a9dd0f288b2a/ansi_off", + "reason": "SELECT map_from_entries(CAST(array() AS array>)) | KRISHIV_UNSUPPORTED_FEATURE: function array" + } + ], + "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..f2d9a38fb --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_keys.json @@ -0,0 +1,38 @@ +{ + "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" + }, + { + "id": "map_keys#a02a683dd54f/ansi_on", + "reason": "SELECT map_keys(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_keys#a02a683dd54f/ansi_off", + "reason": "SELECT map_keys(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_keys#a6e07cd46c69/ansi_on", + "reason": "SELECT map_keys(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_keys#a6e07cd46c69/ansi_off", + "reason": "SELECT map_keys(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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..6fd69a0e2 --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/map_values.json @@ -0,0 +1,38 @@ +{ + "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#ad65f023285d/ansi_on", + "reason": "SELECT map_values(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_values#ad65f023285d/ansi_off", + "reason": "SELECT map_values(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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" + }, + { + "id": "map_values#c3cc2472e0f9/ansi_on", + "reason": "SELECT map_values(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "map_values#c3cc2472e0f9/ansi_off", + "reason": "SELECT map_values(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + } + ], + "format_version": 1, + "function": "map_values" +} diff --git a/tests/fixtures/analysis/registry-matrix/max_by.json b/tests/fixtures/analysis/registry-matrix/max_by.json index b613d1da0..81b7f549c 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 a41bb5cc3..a7d5415f3 100644 --- a/tests/fixtures/analysis/registry-matrix/md5.json +++ b/tests/fixtures/analysis/registry-matrix/md5.json @@ -24,14 +24,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 e826ec155..6eb98aab3 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 e8a32b4ac..b017ca2cd 100644 --- a/tests/fixtures/analysis/registry-matrix/minute.json +++ b/tests/fixtures/analysis/registry-matrix/minute.json @@ -32,14 +32,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 0b9e90de6..3f296329a 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" @@ -44,14 +36,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#8de54b33113f/ansi_on", "reason": "SELECT MOD(2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/month.json b/tests/fixtures/analysis/registry-matrix/month.json index 22b2dfff0..e2af13a36 100644 --- a/tests/fixtures/analysis/registry-matrix/month.json +++ b/tests/fixtures/analysis/registry-matrix/month.json @@ -8,14 +8,6 @@ "id": "month#4d7a9771907c/ansi_off", "reason": "SELECT month(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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 89ad7de49..7e76a0ebb 100644 --- a/tests/fixtures/analysis/registry-matrix/monthname.json +++ b/tests/fixtures/analysis/registry-matrix/monthname.json @@ -16,14 +16,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#63c720d4ce7f/ansi_on", "reason": "SELECT monthname(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 c1823bd2f..acfe0404e 100644 --- a/tests/fixtures/analysis/registry-matrix/months_between.json +++ b/tests/fixtures/analysis/registry-matrix/months_between.json @@ -32,14 +32,6 @@ "id": "months_between#1d6c07f4a83a/ansi_off", "reason": "SELECT months_between(array(1, 2), '1996-10-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "months_between#1de399a111e8/ansi_on", - "reason": "SELECT months_between('1997-02-28 10:30:00', map('a', 1), false) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#2ceaa662f9ec/ansi_on", "reason": "SELECT months_between('1997-02-28 10:30:00', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -124,34 +116,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" @@ -160,14 +128,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#bb82f2d9bdb8/ansi_on", "reason": "SELECT months_between('1997-02-28 10:30:00', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/nanvl.json b/tests/fixtures/analysis/registry-matrix/nanvl.json index 503f6c6ad..a1a482288 100644 --- a/tests/fixtures/analysis/registry-matrix/nanvl.json +++ b/tests/fixtures/analysis/registry-matrix/nanvl.json @@ -8,14 +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#644ae139b068/ansi_on", "reason": "SELECT nanvl(array(1, 2), 123) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "nanvl#6f856e44bbc3/ansi_off", "reason": "SELECT nanvl(cast('NaN' as double), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 2484a0ed2..0ad4cc991 100644 --- a/tests/fixtures/analysis/registry-matrix/negative.json +++ b/tests/fixtures/analysis/registry-matrix/negative.json @@ -24,14 +24,6 @@ "id": "negative#afdcd0b2b9ee/ansi_off", "reason": "SELECT negative(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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 677a9757e..84aa0dd6e 100644 --- a/tests/fixtures/analysis/registry-matrix/next_day.json +++ b/tests/fixtures/analysis/registry-matrix/next_day.json @@ -24,14 +24,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#699c67a69753/ansi_on", "reason": "SELECT next_day('2015-01-14', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,6 @@ "id": "next_day#7e553d3ccfa7/ansi_off", "reason": "SELECT next_day(named_struct('a', 1, 'b', 'x'), 'TU') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 3ce0bdcd9..c9cd57560 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 13ba52b6a..418fdbd27 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 e5919d294..63beca03f 100644 --- a/tests/fixtures/analysis/registry-matrix/nullif.json +++ b/tests/fixtures/analysis/registry-matrix/nullif.json @@ -16,22 +16,6 @@ "id": "nullif#1d230a3a28c9/ansi_off", "reason": "SELECT nullif(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "nullif#8c6ac4b1f807/ansi_on", - "reason": "SELECT nullif(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "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 e89f0e755..e42a02339 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#be53c63a1268/ansi_on", "reason": "SELECT nullifzero(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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 118e76d11..27e920af3 100644 --- a/tests/fixtures/analysis/registry-matrix/nvl.json +++ b/tests/fixtures/analysis/registry-matrix/nvl.json @@ -26,11 +26,11 @@ }, { "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" + "reason": "SELECT nvl(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array 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" + "reason": "SELECT nvl(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, { "id": "nvl#18036545751d/ansi_on", @@ -215,14 +215,6 @@ { "id": "nvl#f89a839e7d85/ansi_off", "reason": "SELECT nvl(NULL, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl#fd2b816559e6/ansi_on", - "reason": "SELECT nvl(NULL, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" - }, - { - "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 79d1e01cb..88b7a860a 100644 --- a/tests/fixtures/analysis/registry-matrix/nvl2.json +++ b/tests/fixtures/analysis/registry-matrix/nvl2.json @@ -48,14 +48,6 @@ "id": "nvl2#5ba4dfd6249b/ansi_off", "reason": "SELECT nvl2(array(1, 2), 2, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array" }, - { - "id": "nvl2#92c35e6b7596/ansi_on", - "reason": "SELECT nvl2(NULL, map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "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" @@ -72,22 +64,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#ccee962457df/ansi_on", "reason": "SELECT nvl2(NULL, 2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/pmod.json b/tests/fixtures/analysis/registry-matrix/pmod.json index 2e4e24369..ae3683ab8 100644 --- a/tests/fixtures/analysis/registry-matrix/pmod.json +++ b/tests/fixtures/analysis/registry-matrix/pmod.json @@ -64,22 +64,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/positive.json b/tests/fixtures/analysis/registry-matrix/positive.json index 048e2e4d7..f04384e6d 100644 --- a/tests/fixtures/analysis/registry-matrix/positive.json +++ b/tests/fixtures/analysis/registry-matrix/positive.json @@ -24,14 +24,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" - }, { "id": "positive#c4866cef096c/ansi_on", "reason": "SELECT positive(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/pow.json b/tests/fixtures/analysis/registry-matrix/pow.json index eca6c4ba1..d6a45fe22 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" @@ -24,14 +16,6 @@ "id": "pow#43948fbfbfd3/ansi_off", "reason": "SELECT pow(named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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 a1077a574..a3ae6a11d 100644 --- a/tests/fixtures/analysis/registry-matrix/power.json +++ b/tests/fixtures/analysis/registry-matrix/power.json @@ -8,14 +8,6 @@ "id": "power#1fb3cb5e732f/ansi_off", "reason": "SELECT power(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "power#50aa498e03a3/ansi_on", - "reason": "SELECT power(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" @@ -71,14 +63,6 @@ { "id": "power#daed4041da08/ansi_off", "reason": "SELECT power(2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 3bd2b4de2..dabafe2dd 100644 --- a/tests/fixtures/analysis/registry-matrix/quarter.json +++ b/tests/fixtures/analysis/registry-matrix/quarter.json @@ -16,14 +16,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/radians.json b/tests/fixtures/analysis/registry-matrix/radians.json index 41971e1e4..fbf34beac 100644 --- a/tests/fixtures/analysis/registry-matrix/radians.json +++ b/tests/fixtures/analysis/registry-matrix/radians.json @@ -16,14 +16,6 @@ "id": "radians#595d7d8afe29/ansi_off", "reason": "SELECT radians(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "radians#a6b560943a35/ansi_on", - "reason": "SELECT radians(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 3884cbedf..742c0ddae 100644 --- a/tests/fixtures/analysis/registry-matrix/raise_error.json +++ b/tests/fixtures/analysis/registry-matrix/raise_error.json @@ -24,14 +24,6 @@ "id": "raise_error#5d4434d2c075/ansi_off", "reason": "SELECT raise_error(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "raise_error#7316fcbbf706/ansi_on", - "reason": "SELECT raise_error(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" - }, { "id": "raise_error#fcc723f51e83/ansi_on", "reason": "SELECT raise_error(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 96668b9ee..37a3391c6 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp.json +++ b/tests/fixtures/analysis/registry-matrix/regexp.json @@ -40,14 +40,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#7e85a4423a0c/ansi_on", "reason": "SELECT regexp(array(1, 2), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -71,14 +63,6 @@ { "id": "regexp#b5e72f23ba3a/ansi_off", "reason": "SELECT regexp('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp#f2d787a50f4c/ansi_on", - "reason": "SELECT regexp(map('a', 1), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 dd1b0f19f..8780d5a45 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_count.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_count.json @@ -8,14 +8,6 @@ "id": "regexp_count#07bc658c7105/ansi_off", "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_count#0afc8da34f72/ansi_on", - "reason": "SELECT regexp_count(map('a', 1), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" @@ -64,14 +56,6 @@ "id": "regexp_count#cdb52bc0b466/ansi_off", "reason": "SELECT regexp_count(array(1, 2), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_count#e50fca3b8f7b/ansi_on", - "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" - }, { "id": "regexp_count#e5e31afb4760/ansi_on", "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/regexp_extract.json b/tests/fixtures/analysis/registry-matrix/regexp_extract.json index 4a5e59875..e984d473e 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" @@ -88,14 +80,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#bbaba3d221ce/ansi_on", "reason": "SELECT regexp_extract('100-200', named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -104,14 +88,6 @@ "id": "regexp_extract#bbaba3d221ce/ansi_off", "reason": "SELECT regexp_extract('100-200', named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_extract#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" - }, { "id": "regexp_extract#fdd1523dc79a/ansi_on", "reason": "SELECT regexp_extract(array(1, 2), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/regexp_instr.json b/tests/fixtures/analysis/registry-matrix/regexp_instr.json index 2407efb9a..379f41ac5 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_instr.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_instr.json @@ -24,14 +24,6 @@ "id": "regexp_instr#2e41d5a7fabc/ansi_off", "reason": "SELECT regexp_instr(named_struct('a', 1, 'b', 'x'), r\"^\\\\abc$\") | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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#782bd946f194/ansi_on", "reason": "SELECT regexp_instr(r\"\\abc\", named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,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#d1b7ae971b09/ansi_on", "reason": "SELECT regexp_instr(r\"\\abc\", array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/regexp_like.json b/tests/fixtures/analysis/registry-matrix/regexp_like.json index e13eba818..78637632d 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_like.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_like.json @@ -24,14 +24,6 @@ "id": "regexp_like#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#890c550d2cad/ansi_on", "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -40,14 +32,6 @@ "id": "regexp_like#890c550d2cad/ansi_off", "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_like#8ed857c04e18/ansi_on", - "reason": "SELECT regexp_like(map('a', 1), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 f14359da6..abea19f7f 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,14 +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#4e808b6ab3ea/ansi_on", "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -88,14 +72,6 @@ "id": "regexp_replace#7e9104eeb35d/ansi_off", "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_replace#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 e89fd3cc2..00ef9235b 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_substr.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_substr.json @@ -63,22 +63,6 @@ { "id": "regexp_substr#a3caad2c31af/ansi_off", "reason": "SELECT regexp_substr(named_struct('a', 1, 'b', 'x'), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_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/replace.json b/tests/fixtures/analysis/registry-matrix/replace.json index 676d2d46b..3cc9ac04c 100644 --- a/tests/fixtures/analysis/registry-matrix/replace.json +++ b/tests/fixtures/analysis/registry-matrix/replace.json @@ -32,14 +32,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#7994c08a31a3/ansi_on", "reason": "SELECT replace(array(1, 2), 'abc', 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,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" @@ -88,14 +72,6 @@ "id": "replace#bf27e8ab957c/ansi_off", "reason": "SELECT replace('ABCabc', 'abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "replace#d9f91490acc7/ansi_on", - "reason": "SELECT replace('ABCabc', map('a', 1), 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#df1872ed019e/ansi_on", "reason": "SELECT replace('ABCabc', named_struct('a', 1, 'b', 'x'), 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/rint.json b/tests/fixtures/analysis/registry-matrix/rint.json index ee85635cd..056e97557 100644 --- a/tests/fixtures/analysis/registry-matrix/rint.json +++ b/tests/fixtures/analysis/registry-matrix/rint.json @@ -31,14 +31,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 21c0a9026..f77f24c86 100644 --- a/tests/fixtures/analysis/registry-matrix/round.json +++ b/tests/fixtures/analysis/registry-matrix/round.json @@ -56,22 +56,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" - }, { "id": "round#f890b98f5266/ansi_on", "reason": "SELECT round(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/rpad.json b/tests/fixtures/analysis/registry-matrix/rpad.json index d3ee085c0..a7daa13d7 100644 --- a/tests/fixtures/analysis/registry-matrix/rpad.json +++ b/tests/fixtures/analysis/registry-matrix/rpad.json @@ -24,14 +24,6 @@ "id": "rpad#0aa877274e17/ansi_off", "reason": "SELECT rpad('hi', 5, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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" @@ -88,22 +80,6 @@ "id": "rpad#6948ac2f6fa7/ansi_off", "reason": "SELECT rpad(named_struct('a', 1, 'b', 'x'), 5) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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" @@ -160,14 +136,6 @@ "id": "rpad#c36fcf5d02d6/ansi_off", "reason": "SELECT rpad(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "rpad#d8ee019cf6cd/ansi_on", - "reason": "SELECT rpad('hi', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#e1759fee6985/ansi_on", "reason": "SELECT rpad(named_struct('a', 1, 'b', 'x'), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -184,14 +152,6 @@ "id": "rpad#e70e9a4e3801/ansi_off", "reason": "SELECT rpad('hi', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "rpad#f3cf473e2510/ansi_on", - "reason": "SELECT rpad(map('a', 1), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 ea0ba67c2..f0be24636 100644 --- a/tests/fixtures/analysis/registry-matrix/rtrim.json +++ b/tests/fixtures/analysis/registry-matrix/rtrim.json @@ -16,14 +16,6 @@ "id": "rtrim#414ec50a8836/ansi_off", "reason": "SELECT rtrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "rtrim#4f1bf1caadb5/ansi_on", - "reason": "SELECT rtrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#c13d5a232435/ansi_on", "reason": "SELECT rtrim(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sec.json b/tests/fixtures/analysis/registry-matrix/sec.json index f29c5652f..6d677bec5 100644 --- a/tests/fixtures/analysis/registry-matrix/sec.json +++ b/tests/fixtures/analysis/registry-matrix/sec.json @@ -24,14 +24,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" - }, { "id": "sec#faa27900f220/ansi_on", "reason": "SELECT sec(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/second.json b/tests/fixtures/analysis/registry-matrix/second.json index 350ab2f27..941e46bd7 100644 --- a/tests/fixtures/analysis/registry-matrix/second.json +++ b/tests/fixtures/analysis/registry-matrix/second.json @@ -40,14 +40,6 @@ "id": "second#b6eb034a6cc6/ansi_off", "reason": "SELECT second(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "second#edf06afe63c6/ansi_on", - "reason": "SELECT second(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "second#edf06afe63c6/ansi_off", - "reason": "SELECT second(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "second#fd396c142b70/ansi_on", "reason": "SELECT second(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sha.json b/tests/fixtures/analysis/registry-matrix/sha.json index 469749024..f50d3ab3e 100644 --- a/tests/fixtures/analysis/registry-matrix/sha.json +++ b/tests/fixtures/analysis/registry-matrix/sha.json @@ -31,14 +31,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 c6ccd880d..ccdb74ab8 100644 --- a/tests/fixtures/analysis/registry-matrix/sha1.json +++ b/tests/fixtures/analysis/registry-matrix/sha1.json @@ -24,14 +24,6 @@ "id": "sha1#a28532e72e2a/ansi_off", "reason": "SELECT sha1(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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" - }, { "id": "sha1#c90b1625d341/ansi_on", "reason": "SELECT sha1(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sha2.json b/tests/fixtures/analysis/registry-matrix/sha2.json index a8eff8707..ed14bb339 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#471a5e7d41fd/ansi_on", "reason": "SELECT sha2(array(1, 2), 256) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,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#b5556c9204ad/ansi_on", "reason": "SELECT sha2('Spark', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/shiftleft.json b/tests/fixtures/analysis/registry-matrix/shiftleft.json index 914829468..18dae1396 100644 --- a/tests/fixtures/analysis/registry-matrix/shiftleft.json +++ b/tests/fixtures/analysis/registry-matrix/shiftleft.json @@ -32,14 +32,6 @@ "id": "shiftleft#43daf427dafa/ansi_off", "reason": "SELECT shiftleft(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "shiftleft#75289f56a862/ansi_on", - "reason": "SELECT shiftleft(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" @@ -71,14 +63,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 4302c0052..0a7e4d1b4 100644 --- a/tests/fixtures/analysis/registry-matrix/shiftright.json +++ b/tests/fixtures/analysis/registry-matrix/shiftright.json @@ -32,14 +32,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#6bd0fe56f2dc/ansi_on", "reason": "SELECT shiftright(4, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,6 @@ "id": "shiftright#6bd0fe56f2dc/ansi_off", "reason": "SELECT shiftright(4, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 27053ae9c..6982205d0 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#5b6f5e1feb81/ansi_on", "reason": "SELECT shiftrightunsigned(4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,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 ad8834757..2a3c925f9 100644 --- a/tests/fixtures/analysis/registry-matrix/sign.json +++ b/tests/fixtures/analysis/registry-matrix/sign.json @@ -40,14 +40,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 1c052f469..95b9b7772 100644 --- a/tests/fixtures/analysis/registry-matrix/signum.json +++ b/tests/fixtures/analysis/registry-matrix/signum.json @@ -47,14 +47,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 a94498871..eb7d69404 100644 --- a/tests/fixtures/analysis/registry-matrix/sin.json +++ b/tests/fixtures/analysis/registry-matrix/sin.json @@ -16,14 +16,6 @@ "id": "sin#30ae963d3d6f/ansi_off", "reason": "SELECT sin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sin#6de2eba5fd5b/ansi_on", - "reason": "SELECT sin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#7b247349b59f/ansi_on", "reason": "SELECT sin(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 1fb024940..a3df8f5bf 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#91f2a84a0321/ansi_on", "reason": "SELECT sinh(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sqrt.json b/tests/fixtures/analysis/registry-matrix/sqrt.json index d32ac1fbd..ed38c5a5a 100644 --- a/tests/fixtures/analysis/registry-matrix/sqrt.json +++ b/tests/fixtures/analysis/registry-matrix/sqrt.json @@ -16,14 +16,6 @@ "id": "sqrt#4396783664f6/ansi_off", "reason": "SELECT sqrt(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sqrt#4cf0f8ae607a/ansi_on", - "reason": "SELECT sqrt(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#609606380f2c/ansi_on", "reason": "SELECT sqrt(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/startswith.json b/tests/fixtures/analysis/registry-matrix/startswith.json index 75e0ed759..edb1a7291 100644 --- a/tests/fixtures/analysis/registry-matrix/startswith.json +++ b/tests/fixtures/analysis/registry-matrix/startswith.json @@ -16,14 +16,6 @@ "id": "startswith#02100ce52833/ansi_off", "reason": "SELECT startswith('Spark SQL', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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" @@ -64,14 +56,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" - }, { "id": "startswith#bf1ab845092b/ansi_on", "reason": "SELECT startswith('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" 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..88c6ffb84 --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/str_to_map.json @@ -0,0 +1,134 @@ +{ + "entries": [ + { + "id": "str_to_map#0006aba37704/ansi_on", + "reason": "SELECT str_to_map(named_struct('a', 1, 'b', 'x'), ',', ':') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#0006aba37704/ansi_off", + "reason": "SELECT str_to_map(named_struct('a', 1, 'b', 'x'), ',', ':') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "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#0cd59e1ddca6/ansi_on", + "reason": "SELECT str_to_map(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#0cd59e1ddca6/ansi_off", + "reason": "SELECT str_to_map(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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#3a0b0446ab52/ansi_on", + "reason": "SELECT str_to_map('a:1,b:2,c:3', named_struct('a', 1, 'b', 'x'), ':') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#3a0b0446ab52/ansi_off", + "reason": "SELECT str_to_map('a:1,b:2,c:3', named_struct('a', 1, 'b', 'x'), ':') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#52e3717ff96d/ansi_on", + "reason": "SELECT str_to_map(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#52e3717ff96d/ansi_off", + "reason": "SELECT str_to_map(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#6f497fe1ceb0/ansi_on", + "reason": "SELECT str_to_map('a:1,b:2,c:3', ',', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#6f497fe1ceb0/ansi_off", + "reason": "SELECT str_to_map('a:1,b:2,c:3', ',', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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#92dc4535c715/ansi_on", + "reason": "SELECT str_to_map('a:1,b:2,c:3', ',', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#92dc4535c715/ansi_off", + "reason": "SELECT str_to_map('a:1,b:2,c:3', ',', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array 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#b582448cfd41/ansi_on", + "reason": "SELECT str_to_map('a:1,b:2,c:3', array(1, 2), ':') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#b582448cfd41/ansi_off", + "reason": "SELECT str_to_map('a:1,b:2,c:3', array(1, 2), ':') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#dc9fda0b6d23/ansi_on", + "reason": "SELECT str_to_map(array(1, 2), ',', ':') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "str_to_map#dc9fda0b6d23/ansi_off", + "reason": "SELECT str_to_map(array(1, 2), ',', ':') | KRISHIV_UNSUPPORTED_FEATURE: function array 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/substr.json b/tests/fixtures/analysis/registry-matrix/substr.json index 70902e1c1..62b454385 100644 --- a/tests/fixtures/analysis/registry-matrix/substr.json +++ b/tests/fixtures/analysis/registry-matrix/substr.json @@ -48,14 +48,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" @@ -72,14 +64,6 @@ "id": "substr#5098f3bdd376/ansi_off", "reason": "SELECT substr(array(1, 2), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substr#723f8b45fc39/ansi_on", - "reason": "SELECT substr('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#733907a378ec/ansi_on", "reason": "SELECT substr(encode('Spark SQL', 'utf-8'), 5) | KRISHIV_UNSUPPORTED_FEATURE: function encode" @@ -88,14 +72,6 @@ "id": "substr#733907a378ec/ansi_off", "reason": "SELECT substr(encode('Spark SQL', 'utf-8'), 5) | KRISHIV_UNSUPPORTED_FEATURE: function encode" }, - { - "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" @@ -136,14 +112,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#b67f2937523e/ansi_on", "reason": "SELECT substr(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -168,14 +136,6 @@ "id": "substr#c4c789f9b7fb/ansi_off", "reason": "SELECT substr('Spark SQL', named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substr#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#eb55cdf8fbe1/ansi_on", "reason": "SELECT substr('Spark SQL', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/substring.json b/tests/fixtures/analysis/registry-matrix/substring.json index 159ac573a..a02e1903a 100644 --- a/tests/fixtures/analysis/registry-matrix/substring.json +++ b/tests/fixtures/analysis/registry-matrix/substring.json @@ -48,22 +48,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" @@ -88,14 +72,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#826898b7fd31/ansi_on", "reason": "SELECT substring(array(1, 2), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -144,14 +120,6 @@ "id": "substring#9dbbbb04884d/ansi_off", "reason": "SELECT substring(named_struct('a', 1, 'b', 'x'), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substring#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#c5ecd3ffb4a7/ansi_on", "reason": "SELECT substring('Spark SQL', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -168,14 +136,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" - }, { "id": "substring#f4a34829cdcf/ansi_on", "reason": "SELECT substring('Spark SQL', named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/tan.json b/tests/fixtures/analysis/registry-matrix/tan.json index 845e62dc5..d12acc05a 100644 --- a/tests/fixtures/analysis/registry-matrix/tan.json +++ b/tests/fixtures/analysis/registry-matrix/tan.json @@ -16,14 +16,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 3dc0e2483..e10769e65 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#bbec36e28d72/ansi_on", "reason": "SELECT tanh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/to_char.json b/tests/fixtures/analysis/registry-matrix/to_char.json index 4a78c60ce..3bfe0013a 100644 --- a/tests/fixtures/analysis/registry-matrix/to_char.json +++ b/tests/fixtures/analysis/registry-matrix/to_char.json @@ -40,22 +40,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 70652f70d..1b670b926 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" @@ -64,14 +56,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 8ef11c24c..00770f6d0 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" @@ -48,14 +40,6 @@ "id": "to_utc_timestamp#78b01f86bbd7/ansi_off", "reason": "SELECT to_utc_timestamp('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "to_utc_timestamp#9ec1404ab832/ansi_on", - "reason": "SELECT to_utc_timestamp(map('a', 1), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#a0a1d553b4b8/ansi_on", "reason": "SELECT to_utc_timestamp(named_struct('a', 1, 'b', 'x'), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/to_varchar.json b/tests/fixtures/analysis/registry-matrix/to_varchar.json index a75f3193d..7b1e910a2 100644 --- a/tests/fixtures/analysis/registry-matrix/to_varchar.json +++ b/tests/fixtures/analysis/registry-matrix/to_varchar.json @@ -32,14 +32,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" @@ -88,14 +80,6 @@ "id": "to_varchar#cce983c75f34/ansi_off", "reason": "SELECT to_varchar(454, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "to_varchar#ebf434f037b3/ansi_on", - "reason": "SELECT to_varchar(454, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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/trim.json b/tests/fixtures/analysis/registry-matrix/trim.json index 188e769e6..a3685ed07 100644 --- a/tests/fixtures/analysis/registry-matrix/trim.json +++ b/tests/fixtures/analysis/registry-matrix/trim.json @@ -31,14 +31,6 @@ { "id": "trim#f3c2ecedc771/ansi_off", "reason": "SELECT trim(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "trim#ff7e17fd365a/ansi_on", - "reason": "SELECT trim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 aa730b8cc..bc1df3ebd 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#46ec428ec220/ansi_on", "reason": "SELECT trunc(array(1, 2), 'week') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,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 71322969f..ee66507c9 100644 --- a/tests/fixtures/analysis/registry-matrix/try_add.json +++ b/tests/fixtures/analysis/registry-matrix/try_add.json @@ -44,14 +44,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" @@ -164,14 +156,6 @@ "id": "try_add#8b46cf1077d3/ansi_off", "reason": "SELECT try_add(named_struct('a', 1, 'b', 'x'), 2) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "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 6438cc3e5..59f19c4d3 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" @@ -68,14 +60,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 d773f0e40..5b18ccb1b 100644 --- a/tests/fixtures/analysis/registry-matrix/try_mod.json +++ b/tests/fixtures/analysis/registry-matrix/try_mod.json @@ -16,14 +16,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" @@ -52,14 +44,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 eca90cff9..f8ef55453 100644 --- a/tests/fixtures/analysis/registry-matrix/try_multiply.json +++ b/tests/fixtures/analysis/registry-matrix/try_multiply.json @@ -40,22 +40,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_subtract.json b/tests/fixtures/analysis/registry-matrix/try_subtract.json index 898c34fad..d398dada2 100644 --- a/tests/fixtures/analysis/registry-matrix/try_subtract.json +++ b/tests/fixtures/analysis/registry-matrix/try_subtract.json @@ -228,14 +228,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" @@ -255,14 +247,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_number.json b/tests/fixtures/analysis/registry-matrix/try_to_number.json index 725924c3c..711fe8d30 100644 --- a/tests/fixtures/analysis/registry-matrix/try_to_number.json +++ b/tests/fixtures/analysis/registry-matrix/try_to_number.json @@ -8,14 +8,6 @@ "id": "try_to_number#14343461e39f/ansi_off", "reason": "SELECT try_to_number(named_struct('a', 1, 'b', 'x'), '999') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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" @@ -40,14 +32,6 @@ "id": "try_to_number#432866f79de1/ansi_off", "reason": "SELECT try_to_number('454', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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#69b8cbb7518e/ansi_on", "reason": "SELECT try_to_number('454', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/ucase.json b/tests/fixtures/analysis/registry-matrix/ucase.json index bfb8d688e..06a7beb00 100644 --- a/tests/fixtures/analysis/registry-matrix/ucase.json +++ b/tests/fixtures/analysis/registry-matrix/ucase.json @@ -16,14 +16,6 @@ "id": "ucase#7d9d4bbe7436/ansi_off", "reason": "SELECT ucase(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "ucase#9de2d667346e/ansi_on", - "reason": "SELECT ucase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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#d170ded41cbd/ansi_on", "reason": "SELECT ucase(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/unix_date.json b/tests/fixtures/analysis/registry-matrix/unix_date.json index a44bdcd7d..c446f6dd0 100644 --- a/tests/fixtures/analysis/registry-matrix/unix_date.json +++ b/tests/fixtures/analysis/registry-matrix/unix_date.json @@ -32,14 +32,6 @@ "id": "unix_date#3b2372176abc/ansi_off", "reason": "SELECT unix_date(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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" - }, { "id": "unix_date#e49b5743d3da/ansi_on", "reason": "SELECT unix_date(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/upper.json b/tests/fixtures/analysis/registry-matrix/upper.json index 68254113d..1aa57a1de 100644 --- a/tests/fixtures/analysis/registry-matrix/upper.json +++ b/tests/fixtures/analysis/registry-matrix/upper.json @@ -16,14 +16,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/weekday.json b/tests/fixtures/analysis/registry-matrix/weekday.json index 1b31fe52e..b18ad918b 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#7ace552f16ce/ansi_on", "reason": "SELECT weekday(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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 83cc2b2e9..9ecaad37d 100644 --- a/tests/fixtures/analysis/registry-matrix/weekofyear.json +++ b/tests/fixtures/analysis/registry-matrix/weekofyear.json @@ -8,14 +8,6 @@ "id": "weekofyear#1e22d97eacaf/ansi_off", "reason": "SELECT weekofyear(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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 ef3a4b91a..72f9a8cca 100644 --- a/tests/fixtures/analysis/registry-matrix/xxhash64.json +++ b/tests/fixtures/analysis/registry-matrix/xxhash64.json @@ -66,11 +66,11 @@ }, { "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#2c84929b4420/ansi_on", @@ -434,11 +434,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) | KRISHIV_UNSUPPORTED_FEATURE: function array 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) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "xxhash64#f79d45019309/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/year.json b/tests/fixtures/analysis/registry-matrix/year.json index 3f77c839a..600560f3a 100644 --- a/tests/fixtures/analysis/registry-matrix/year.json +++ b/tests/fixtures/analysis/registry-matrix/year.json @@ -24,14 +24,6 @@ "id": "year#98b02509736a/ansi_off", "reason": "SELECT year(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "year#c5aacd8222e2/ansi_on", - "reason": "SELECT year(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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 325ca60cb..49f8477cc 100644 --- a/tests/fixtures/analysis/registry-matrix/zeroifnull.json +++ b/tests/fixtures/analysis/registry-matrix/zeroifnull.json @@ -24,14 +24,6 @@ "id": "zeroifnull#5369bb95092d/ansi_off", "reason": "SELECT zeroifnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "zeroifnull#583a6c570fa6/ansi_on", - "reason": "SELECT zeroifnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "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/higher-order-functions.json b/tests/spark-golden/known-failures-cases/higher-order-functions.json index 8f222adbb..a1f3e1436 100644 --- a/tests/spark-golden/known-failures-cases/higher-order-functions.json +++ b/tests/spark-golden/known-failures-cases/higher-order-functions.json @@ -90,8 +90,7 @@ 33 ], "sql-commands": [ - 0, - 25 + 0 ] }, "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 ce0b067c7..78174dafd 100644 --- a/tests/spark-golden/known-failures-cases/literals.json +++ b/tests/spark-golden/known-failures-cases/literals.json @@ -8,9 +8,6 @@ "fn-array": [ 48 ], - "fn-map": [ - 47 - ], "fn-struct": [ 49 ], 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 894713271..e5f9aa733 100644 --- a/tests/spark-golden/known-failures-cases/misc-functions.json +++ b/tests/spark-golden/known-failures-cases/misc-functions.json @@ -12,8 +12,7 @@ 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 a0f6f27d0..bed4c7917 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 @@ -90,8 +90,7 @@ 33 ], "sql-commands": [ - 0, - 25 + 0 ] }, "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 ef95690f6..c2faba605 100644 --- a/tests/spark-golden/known-failures-cases/nonansi/literals.json +++ b/tests/spark-golden/known-failures-cases/nonansi/literals.json @@ -8,9 +8,6 @@ "fn-array": [ 48 ], - "fn-map": [ - 47 - ], "fn-struct": [ 49 ], 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/union.json b/tests/spark-golden/known-failures-cases/union.json index d8377dc6e..04a80acf6 100644 --- a/tests/spark-golden/known-failures-cases/union.json +++ b/tests/spark-golden/known-failures-cases/union.json @@ -8,9 +8,6 @@ "fn-array": [ 11 ], - "fn-map": [ - 10 - ], "sql-commands": [ 2, 12, diff --git a/tests/spark-golden/known-failures.json b/tests/spark-golden/known-failures.json index a3b297741..2f4401ff8 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_*)", @@ -364,12 +359,6 @@ "collection" ] }, - { - "category": "fn-map", - "family": [ - "map" - ] - }, { "category": "fn-struct", "family": [ From 70101e055974528d2c95122f83a2ae7e3222bcab Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Sun, 25 Oct 2026 23:57:26 +0100 Subject: [PATCH 2/4] Map kernels: report internal inconsistencies as errors; pin the map type errors Hash and list-range lookups in the map kernels no longer substitute zero or an empty range; a missing entry is an internal error. Adds analysis-level tests for CREATE_MAP_KEY_DIFF_TYPES, CREATE_MAP_VALUE_DIFF_TYPES and MAP_CONCAT_DIFF_TYPES, and drops the implemented str_to_map from the unsupported list in the crate notes. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- crates/krishiv-functions/CLAUDE.md | 4 +- crates/krishiv-kernels/src/map.rs | 107 ++++++++++-------- .../krishiv-session/tests/map_type_errors.rs | 39 +++++++ 3 files changed, 98 insertions(+), 52 deletions(-) create mode 100644 crates/krishiv-session/tests/map_type_errors.rs diff --git a/crates/krishiv-functions/CLAUDE.md b/crates/krishiv-functions/CLAUDE.md index a03a1eefd..49ab718cc 100644 --- a/crates/krishiv-functions/CLAUDE.md +++ b/crates/krishiv-functions/CLAUDE.md @@ -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-kernels/src/map.rs b/crates/krishiv-kernels/src/map.rs index e3c2b4be4..49f74faeb 100644 --- a/crates/krishiv-kernels/src/map.rs +++ b/crates/krishiv-kernels/src/map.rs @@ -123,6 +123,14 @@ 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`). @@ -493,7 +501,7 @@ impl<'a> Deduped<'a> { if e.keys.is_null(e.key) { return Err(KernelError::with_row(Some(row), NullMapKey {}.into())); } - let h = hash.get(at).copied().unwrap_or(0); + let h = hash_at(hash, at)?; at = at.saturating_add(1); let mut found = None; if let Some(same) = seen.get(&h) { @@ -509,7 +517,7 @@ impl<'a> Deduped<'a> { if policy == DedupPolicy::Exception { return Err(KernelError::with_row( Some(row), - duplicate_key(e.keys, e.key), + duplicate_key(e.keys, e.key)?, )); } kept[p].values = e.values; @@ -528,12 +536,12 @@ impl<'a> Deduped<'a> { } /// `DUPLICATED_MAP_KEY` for the key value, rendered as Spark renders it. -fn duplicate_key(keys: &dyn Array, key: usize) -> KrishivError { - DuplicatedMapKey { - key: key_text(keys, key), +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() + .into()) } /// Spark's `key.toString` for a key value: strings as they are, numbers by @@ -541,58 +549,56 @@ fn duplicate_key(keys: &dyn Array, key: usize) -> KrishivError { /// 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) -> String { +fn key_text(keys: &dyn Array, key: usize) -> Result { use DataType as T; match keys.data_type() { - T::Utf8 | T::Utf8View | T::LargeUtf8 => string_value(keys, key).to_owned(), - T::Boolean => keys.as_boolean().value(key).to_string(), - T::Int8 => keys.as_primitive::().value(key).to_string(), - T::Int16 => keys.as_primitive::().value(key).to_string(), - T::Int32 => keys.as_primitive::().value(key).to_string(), - T::Int64 => keys.as_primitive::().value(key).to_string(), - T::UInt8 => keys.as_primitive::().value(key).to_string(), - T::UInt16 => keys.as_primitive::().value(key).to_string(), - T::UInt32 => keys.as_primitive::().value(key).to_string(), - T::UInt64 => keys.as_primitive::().value(key).to_string(), + 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() { - "NaN".to_owned() + Ok("NaN".to_owned()) } else { - format!("{v:?}") + Ok(format!("{v:?}")) } } T::Float64 => { let v = keys.as_primitive::().value(key); if v.is_nan() { - "NaN".to_owned() + Ok("NaN".to_owned()) } else { - format!("{v:?}") + Ok(format!("{v:?}")) } } T::Decimal128(_, scale) => { decimal_text(keys.as_primitive::().value(key), *scale) } - T::Binary | T::BinaryView | T::LargeBinary => { - format!("{:?}", binary_value(keys, key)) - } - T::Date32 => keys.as_primitive::().value(key).to_string(), - T::Timestamp(..) => keys + 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(), + .to_string()), T::List(_) | T::LargeList(_) => { - let (from, to) = list_range(keys, key).unwrap_or((0, 0)); + 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) + key_text(values.as_ref(), p)? }); } - format!("[{}]", parts.join(", ")) + Ok(format!("[{}]", parts.join(", "))) } T::Struct(_) => { let s = keys.as_struct(); @@ -601,27 +607,27 @@ fn key_text(keys: &dyn Array, key: usize) -> String { parts.push(if col.is_null(key) { "null".to_owned() } else { - key_text(col.as_ref(), key) + key_text(col.as_ref(), key)? }); } - format!("[{}]", parts.join(", ")) + Ok(format!("[{}]", parts.join(", "))) } - _ => format!("{:?}", keys), + _ => Ok(format!("{:?}", keys)), } } /// A decimal unscaled value with `scale` digits after the point. -fn decimal_text(unscaled: i128, scale: i8) -> String { - let scale = usize::try_from(scale.max(0)).unwrap_or(0); +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 { - format!("{sign}{int}") + Ok(format!("{sign}{int}")) } else { - format!("{sign}{int}.{frac}") + Ok(format!("{sign}{int}.{frac}")) } } @@ -700,7 +706,7 @@ pub fn create_map( .checked_mul(rows) .and_then(|at| at.checked_add(r)) .ok_or_else(|| internal("map entries past their hashes"))?; - ordered.push(hash.get(at).copied().unwrap_or(0)); + ordered.push(hash_at(&hash, at)?); row.push(Entry { keys: k.as_ref(), key: r, @@ -757,10 +763,11 @@ pub fn concat( for (mi, m) in marrays.iter().enumerate() { let (from, to) = map_range(m, r)?; for p in from..to { - let h = hash - .get(base.get(mi).copied().unwrap_or(0).saturating_add(p)) + let base_at = base + .get(mi) .copied() - .unwrap_or(0); + .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(), @@ -918,7 +925,7 @@ pub fn from_arrays( } let mut row = Vec::with_capacity(kt.saturating_sub(kf)); for (p, q) in (kf..kt).zip(vf..vt) { - ordered.push(hash.get(p).copied().unwrap_or(0)); + ordered.push(hash_at(&hash, p)?); row.push(Entry { keys: k.values().as_ref(), key: p, @@ -974,7 +981,7 @@ pub fn from_entries( null_element = true; break; } - ordered.push(hash.get(p).copied().unwrap_or(0)); + ordered.push(hash_at(&hash, p)?); row.push(Entry { keys: keys.as_ref(), key: p, @@ -1038,7 +1045,7 @@ pub fn from_pairs( let Some(row) = per_row.get_mut(*r) else { return Err(internal("a str_to_map pair past its rows")); }; - ordered.push(hash.get(p).copied().unwrap_or(0)); + ordered.push(hash_at(&hash, p)?); row.push(Entry { keys: keys.as_ref(), key: p, @@ -1105,7 +1112,7 @@ mod tests { 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); + let k = key_text(m.keys().as_ref(), p).expect("key text renders"); let v = if m.values().is_null(p) { None } else { @@ -1414,7 +1421,7 @@ mod tests { let (from, to) = map_range(&m, rows - 1).unwrap(); assert_eq!((to - from), 1); assert_eq!( - key_text(m.keys().as_ref(), from), + key_text(m.keys().as_ref(), from).expect("key text renders"), (i32::try_from(rows).unwrap_or(0).saturating_sub(1)).to_string() ); } @@ -1756,10 +1763,10 @@ mod tests { #[test] fn decimal_text_renders() { - assert_eq!(decimal_text(100, 2), "1.00"); - assert_eq!(decimal_text(-5, 3), "-0.005"); - assert_eq!(decimal_text(0, 0), "0"); - assert_eq!(decimal_text(12345, 0), "12345"); + 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] 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 + ); +} From 274c5d448cf4bc60acade80d902fa58434e67f6e Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Mon, 26 Oct 2026 02:36:49 +0100 Subject: [PATCH 3/4] test: cover map key comparison across carriers and the CLI map renderer Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- crates/krishiv-cli/src/sql.rs | 14 ++++ crates/krishiv-kernels/src/map.rs | 110 ++++++++++++++++++++++++++++++ 2 files changed, 124 insertions(+) diff --git a/crates/krishiv-cli/src/sql.rs b/crates/krishiv-cli/src/sql.rs index 1544f152c..b6a2564a4 100644 --- a/crates/krishiv-cli/src/sql.rs +++ b/crates/krishiv-cli/src/sql.rs @@ -638,6 +638,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-kernels/src/map.rs b/crates/krishiv-kernels/src/map.rs index 49f74faeb..a5acc00a3 100644 --- a/crates/krishiv-kernels/src/map.rs +++ b/crates/krishiv-kernels/src/map.rs @@ -1794,4 +1794,114 @@ mod tests { .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 name. + 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()); + } } From 0df9f1c6d2209f8190359a2459174cb1836713a3 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:31:45 +0100 Subject: [PATCH 4/4] test(functions): refresh the registry-matrix manifest after the merge with main map() now resolves, so the parse_url and try_parse_url cases over a map argument pass and leave the manifest; schema_of_csv over a map now reports NON_FOLDABLE_INPUT (Spark: UNEXPECTED_INPUT_TYPE) and stays listed. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- .../analysis/registry-matrix/parse_url.json | 40 ------------------- .../registry-matrix/schema_of_csv.json | 4 +- .../registry-matrix/try_parse_url.json | 40 ------------------- 3 files changed, 2 insertions(+), 82 deletions(-) diff --git a/tests/fixtures/analysis/registry-matrix/parse_url.json b/tests/fixtures/analysis/registry-matrix/parse_url.json index 5e90c5077..abdf29a13 100644 --- a/tests/fixtures/analysis/registry-matrix/parse_url.json +++ b/tests/fixtures/analysis/registry-matrix/parse_url.json @@ -48,14 +48,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#75e4f435de67/ansi_on", "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -88,22 +80,6 @@ "id": "parse_url#7f164b6a4717/ansi_off", "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', array(1, 2), 'query') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "parse_url#81533c28fb16/ansi_on", - "reason": "SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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" @@ -136,22 +112,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/schema_of_csv.json b/tests/fixtures/analysis/registry-matrix/schema_of_csv.json index cae1dca84..e59edb967 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/try_parse_url.json b/tests/fixtures/analysis/registry-matrix/try_parse_url.json index 435a34164..51979b515 100644 --- a/tests/fixtures/analysis/registry-matrix/try_parse_url.json +++ b/tests/fixtures/analysis/registry-matrix/try_parse_url.json @@ -8,14 +8,6 @@ "id": "try_parse_url#0dde74e198ba/ansi_off", "reason": "SELECT try_parse_url(named_struct('a', 1, 'b', 'x'), 'HOST') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "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" @@ -32,14 +24,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" @@ -88,14 +72,6 @@ "id": "try_parse_url#31b9fb5d1644/ansi_off", "reason": "SELECT try_parse_url(named_struct('a', 1, 'b', 'x'), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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" @@ -120,14 +96,6 @@ "id": "try_parse_url#53b39a1f6c3a/ansi_off", "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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" @@ -152,14 +120,6 @@ "id": "try_parse_url#ab5a2caeb7d9/ansi_off", "reason": "SELECT try_parse_url(array(1, 2), 'QUERY', 'query') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "try_parse_url#adc8c07a0fc6/ansi_on", - "reason": "SELECT try_parse_url('http://spark.apache.org/path?query=1', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "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"