From fee23639ce38fc0642349e1a3a24af7102ba662b Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Sun, 25 Oct 2026 17:03:40 +0100 Subject: [PATCH 1/7] functions: lambdas with transform, filter, exists and forall (P2-T036, part 1) Higher-order functions over arrays, working from the largest golden group down: transform (15 statements), filter, exists and forall. Lambdas lower to a new plan node; the analyzer binds lambda variables against the argument's array element type and resolves bodies with outer columns visible (Spark's NamedLambdaVariable, shadowing included). A non-lambda argument is a constant lambda, as Spark analyzes it, including its error texts. Execution flattens each list column once, evaluates the body over the flattened batch, and rebuilds lists from the original offsets; kernels work on Arrow ListArrays directly, never one Rust value per row. Also adds the minimal array() constructor these functions need (common element type), the lambda_functions plan-codec feature, the Python wrapper for array(), and nested (array/map/struct) rendering in the golden harness so result goldens can pass. Golden higher-order-functions: 83 failing before, 60 after (23 fixed, none newly failing); registry-matrix and coercion manifests shrink accordingly, and several array() statements elsewhere pass now. Left for follow-ups: aggregate/reduce, zip_with, map_filter, transform_keys/transform_values, map_zip_with, array_sort with comparator, Python Column lambdas, correlated references and scalar subqueries in lambda bodies. Unverified against a Spark run: exists/forall null-mark folding (kept as Spark's source shape) and forall over null arrays; the constant comparator short-circuit of array_sort is deferred with that function. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- Cargo.lock | 1 + crates/krishiv-exec/src/planner/eval/func.rs | 5 +- crates/krishiv-exec/src/planner/eval/hof.rs | 365 +++++++++++++++++ crates/krishiv-exec/src/planner/eval/mod.rs | 23 ++ .../src/python_wrappers/table.rs | 18 +- crates/krishiv-functions/src/registry/defs.rs | 1 + crates/krishiv-functions/src/registry/hof.rs | 173 ++++++++ crates/krishiv-functions/src/registry/mod.rs | 6 + .../krishiv-functions/src/registry/tests.rs | 76 +++- crates/krishiv-functions/src/scalar/array.rs | 54 +++ crates/krishiv-functions/src/scalar/mod.rs | 33 +- .../src/scalar/regex/tests.rs | 4 +- .../krishiv-functions/src/scalar/tests/mod.rs | 2 +- crates/krishiv-kernels/Cargo.toml | 1 + crates/krishiv-kernels/src/lib.rs | 1 + crates/krishiv-kernels/src/list.rs | 274 +++++++++++++ crates/krishiv-kernels/src/list/tests.rs | 250 ++++++++++++ crates/krishiv-plan-codec/src/decode.rs | 9 +- crates/krishiv-plan-codec/src/encode.rs | 7 + crates/krishiv-plan-codec/src/features.rs | 106 +++-- .../src/proto/krishiv.plan.v1.pb.rs | 18 +- .../tests/common/inventory.rs | 54 +++ crates/krishiv-plan-codec/tests/features.rs | 28 ++ .../lambda_functions/lambda_functions.bin | Bin 0 -> 1100 bytes crates/krishiv-plan-codec/tests/roundtrip.rs | 2 +- crates/krishiv-plan/src/analyzer/exprs.rs | 91 ++++- crates/krishiv-plan/src/analyzer/hof.rs | 316 +++++++++++++++ crates/krishiv-plan/src/analyzer/mod.rs | 1 + crates/krishiv-plan/src/analyzer/resolve.rs | 4 + crates/krishiv-plan/src/display.rs | 6 +- crates/krishiv-plan/src/encode.rs | 9 + crates/krishiv-plan/src/expr.rs | 37 +- crates/krishiv-plan/src/tests/inventory.rs | 2 + crates/krishiv-plan/src/tests/props.rs | 8 +- crates/krishiv-plan/src/walk.rs | 12 +- .../tests/datetime_calendar.rs | 5 +- crates/krishiv-session/tests/higher_order.rs | 375 +++++++++++++++++ crates/krishiv-sql/src/lower.rs | 6 +- ...cts_lower_or_are_named_as_unsupported.snap | 3 +- .../src/golden/session_engine.rs | 188 +++++++++ proto/krishiv/plan/v1/plan.proto | 12 + python/krishiv/sql/_generated_functions.py | 6 + python/krishiv/sql/_generated_functions.pyi | 2 + python/tests/_pyspark_signatures.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/array.json | 102 +++++ .../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/exists.json | 86 ++++ .../analysis/registry-matrix/exp.json | 8 - .../analysis/registry-matrix/expm1.json | 8 - .../analysis/registry-matrix/filter.json | 46 +++ .../analysis/registry-matrix/first.json | 8 - .../analysis/registry-matrix/first_value.json | 8 - .../analysis/registry-matrix/floor.json | 24 -- .../analysis/registry-matrix/forall.json | 94 +++++ .../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 | 376 +----------------- .../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 | 160 -------- .../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/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 | 160 -------- .../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/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/transform.json | 38 ++ .../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 | 376 +----------------- .../analysis/registry-matrix/year.json | 8 - .../analysis/registry-matrix/zeroifnull.json | 8 - .../typeCoercion/native/mapZipWith.json | 36 +- .../known-failures-cases/array.json | 2 - .../known-failures-cases/except-all.json | 9 - .../group-by-all-mosha.json | 14 +- .../known-failures-cases/having.json | 1 - .../higher-order-functions.json | 25 -- .../known-failures-cases/inline-table.json | 1 - .../known-failures-cases/intersect-all.json | 1 - .../known-failures-cases/literals.json | 3 - .../known-failures-cases/nonansi/array.json | 2 - .../nonansi/higher-order-functions.json | 25 -- .../nonansi/literals.json | 3 - .../known-failures-cases/pipe-operators.json | 1 - .../known-failures-cases/selectExcept.json | 2 - .../known-failures-cases/union.json | 3 - 223 files changed, 2934 insertions(+), 3311 deletions(-) create mode 100644 crates/krishiv-exec/src/planner/eval/hof.rs create mode 100644 crates/krishiv-functions/src/registry/hof.rs create mode 100644 crates/krishiv-functions/src/scalar/array.rs create mode 100644 crates/krishiv-kernels/src/list.rs create mode 100644 crates/krishiv-kernels/src/list/tests.rs create mode 100644 crates/krishiv-plan-codec/tests/golden/lambda_functions/lambda_functions.bin create mode 100644 crates/krishiv-plan/src/analyzer/hof.rs create mode 100644 crates/krishiv-session/tests/higher_order.rs create mode 100644 tests/fixtures/analysis/registry-matrix/array.json create mode 100644 tests/fixtures/analysis/registry-matrix/exists.json create mode 100644 tests/fixtures/analysis/registry-matrix/filter.json create mode 100644 tests/fixtures/analysis/registry-matrix/forall.json create mode 100644 tests/fixtures/analysis/registry-matrix/transform.json delete mode 100644 tests/spark-golden/known-failures-cases/except-all.json diff --git a/Cargo.lock b/Cargo.lock index eb1b53d4f..03e61434a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1586,6 +1586,7 @@ dependencies = [ "arrow-array", "arrow-buffer", "arrow-schema", + "arrow-select", "codspeed-criterion-compat", "krishiv-common", "libm", diff --git a/crates/krishiv-exec/src/planner/eval/func.rs b/crates/krishiv-exec/src/planner/eval/func.rs index e469091f7..8e265272a 100644 --- a/crates/krishiv-exec/src/planner/eval/func.rs +++ b/crates/krishiv-exec/src/planner/eval/func.rs @@ -28,7 +28,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(); diff --git a/crates/krishiv-exec/src/planner/eval/hof.rs b/crates/krishiv-exec/src/planner/eval/hof.rs new file mode 100644 index 000000000..8cd2bb15c --- /dev/null +++ b/crates/krishiv-exec/src/planner/eval/hof.rs @@ -0,0 +1,365 @@ +// SPDX-License-Identifier: Apache-2.0 +//! Higher-order functions over arrays: `transform`, `filter`, `exists` and +//! `forall`. The lambda body compiles once against a flattened batch, then +//! evaluates once per batch over every list element; the list kernels only +//! reshape (see `krishiv_kernels::list`). +//! +//! For a batch of `rows` rows whose lists hold `total` elements, the +//! flattened batch has `total` rows: the lambda's element column is the +//! list's child values, its index column (two-variable `transform`) counts +//! positions within each list, and every captured outer column repeats its +//! row's value per element (through the lists' offsets). The body runs +//! once over that batch — never one evaluation per element — and the +//! result rebuilds the lists with the original offsets (NULL lists stay +//! NULL). + +use std::sync::Arc; + +use arrow_array::cast::AsArray; +use arrow_array::{Array, ArrayRef, Int32Array, RecordBatch, UInt32Array}; +use arrow_schema::{DataType as ArrowType, Field, Schema}; +use krishiv_kernels::list; +use krishiv_plan::{AttrId, BoundColumn, Expr, ExprNode, ResolvedExpr, ResolvedFunction}; + +use super::{Input, PhysExpr, Value}; +use crate::error::Result; +use crate::planner::build::{internal, unsupported}; +use krishiv_common::error::KrishivError; + +/// Whether `compile` handles `name` here (the analyzer's higher-order +/// functions over arrays). +pub(super) fn is_supported(name: &str) -> bool { + matches!(name, "transform" | "filter" | "exists" | "forall") +} + +/// Compiles the higher-order call `f` (see the module doc). +/// +/// # Errors +/// An engine error when the plan is not what the analyzer resolves. +pub(super) fn compile( + name: &str, + f: &ResolvedFunction, + input: Input<'_>, + _e: &Expr, +) -> Result> { + let [array_expr, lambda_expr] = f.args.as_slice() else { + return Err(internal("a higher-order call without its array and lambda")); + }; + let ExprNode::Lambda { params, body } = &lambda_expr.node else { + return Err(internal("a higher-order call without a lambda")); + }; + let array = super::compile(array_expr, input)?; + let ArrowType::List(field) = array.data_type().clone() else { + return Err(internal("a higher-order call over a non-list")); + }; + let mut refs = Refs::default(); + collect(body, 0, params, &mut Vec::new(), &mut refs); + // The flattened batch's columns: the captured outer columns, then this + // call's element variables and index. A scalar subquery reads the root + // batch, which a nested call no longer sees, so bodies may not hold + // one. + if refs + .outer + .iter() + .any(|id| input.subqueries.iter().any(|(a, _)| a == id)) + { + return Err(unsupported("scalar subqueries in lambda functions")); + } + let mut layout: Vec = Vec::new(); + let mut fields: Vec = Vec::new(); + let mut sources: Vec = Vec::new(); + for id in refs.outer { + let index = input + .layout + .iter() + .position(|a| *a == id) + .ok_or_else(|| internal("a higher-order capture outside its input"))?; + let field = input.schema.field(index); + layout.push(id); + // The real nullability: bindings of nested values read it. + fields.push(Field::new( + format!("c{}", fields.len()), + field.data_type().clone(), + field.is_nullable(), + )); + sources.push(Source::Root(index)); + } + for var in refs.outer_lambda { + let index = input + .layout + .iter() + .position(|a| *a == var.id) + .ok_or_else(|| internal("an enclosing lambda variable outside its input"))?; + layout.push(var.id); + fields.push(Field::new( + format!("c{}", fields.len()), + var.data_type.to_arrow(), + var.nullable, + )); + // An enclosing call flattened this variable already: like a root + // column, it repeats per element of this call's lists. + sources.push(Source::Root(index)); + } + let element = field.data_type().clone(); + let element_nullable = field.is_nullable(); + for id in refs.lambda { + layout.push(id); + fields.push(Field::new( + format!("c{}", fields.len()), + element.clone(), + element_nullable, + )); + sources.push(Source::Element); + } + if let Some(id) = refs.index { + layout.push(id); + fields.push(Field::new( + format!("c{}", fields.len()), + ArrowType::Int32, + false, + )); + sources.push(Source::Index); + } + let schema = Arc::new(Schema::new(fields)); + let body = super::compile( + body, + Input { + layout: &layout, + schema: &schema, + env: input.env, + subqueries: input.subqueries, + }, + )?; + let out = f.data_type.to_arrow(); + Ok(Arc::new(Call { + name: name.to_owned(), + array, + body, + sources, + out, + nullable: f.nullable, + })) +} + +/// The columns a lambda body reads: root columns and enclosing calls' +/// lambda variables at any depth (each level carries what the levels below +/// need), and this call's element and index variables (depth 0). +#[derive(Default)] +struct Refs { + /// Captured root columns, in first-use order. + outer: Vec, + /// Enclosing calls' lambda variables, in first-use order. + outer_lambda: Vec, + /// This call's element variables, in first-use order. + lambda: Vec, + /// This call's index variable, if used. + index: Option, +} + +/// Collects `refs` from `body` against `params`, the enclosing lambda's +/// parameters (a nested lambda collects against its own). A variable of an +/// enclosing call is an outer reference here, carried through this level's +/// flattened batch. +fn collect( + body: &Arc, + depth: usize, + params: &[String], + below: &mut Vec, + refs: &mut Refs, +) { + match &body.node { + ExprNode::Lambda { + params: inner, + body: nested, + } => { + below.extend(inner.iter().cloned()); + collect(nested, depth + 1, inner, below, refs); + below.truncate(below.len() - inner.len()); + } + ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => { + // The innermost scope naming the variable, exactly like the + // analyzer resolves it, then case-insensitively. + let at = |scope: &[String]| { + scope + .iter() + .position(|p| p == &c.name) + .or_else(|| scope.iter().position(|p| p.eq_ignore_ascii_case(&c.name))) + }; + if depth == 0 && at(params) == Some(0) { + if !refs.lambda.contains(&c.id) { + refs.lambda.push(c.id); + } + } else if depth == 0 && at(params).is_some() { + if refs.index.is_none() { + refs.index = Some(c.id); + } + } else if depth == 0 || at(below).is_none() { + // Bound outside the current call (or the current call has + // no such parameter): carried by this level's flattened + // batch. A variable a nested call binds is that call's + // own: its flattening carries it, never this one. + if !refs.outer_lambda.iter().any(|v| v.id == c.id) { + refs.outer_lambda.push(c.clone()); + } + } + } + ExprNode::Resolved(ResolvedExpr::Column(c)) => { + if !refs.outer.contains(&c.id) { + refs.outer.push(c.id); + } + } + _ => body.for_each_child(&mut |c| collect(c, depth, params, below, refs)), + } +} + +/// Where one flattened-batch column comes from: every source repeats one +/// value per element of its row. +#[derive(Debug, Clone, Copy)] +enum Source { + /// The input batch's column (a root column, or an enclosing flattened + /// batch's column for a nested call), repeated per element. + Root(usize), + /// The list's child values. + Element, + /// Positions within each list. + Index, +} + +/// A count that does not fit its carrier. +fn too_many(n: usize) -> KrishivError { + internal(&format!("a higher-order batch of {n} rows")) +} + +/// A bound higher-order call. +#[derive(Debug)] +struct Call { + name: String, + array: Arc, + body: Arc, + sources: Vec, + out: ArrowType, + nullable: bool, +} + +impl PhysExpr for Call { + fn data_type(&self) -> &ArrowType { + &self.out + } + + fn nullable(&self) -> bool { + self.nullable + } + + fn eval(&self, batch: &RecordBatch) -> Result { + let rows = batch.num_rows(); + let array = self.array.eval(batch)?.into_array(rows)?; + if array.len() != rows { + return Err(internal("a higher-order array of the wrong row count")); + } + let list = array + .as_list_opt::() + .ok_or_else(|| internal("a higher-order array that is no list"))?; + let offsets = list.value_offsets(); + let at = |i: usize| { + usize::try_from(offsets[i]) + .map_err(|_| internal("a higher-order list with a negative offset")) + }; + let total = at(rows)?; + if list.values().len() < total { + return Err(internal("a higher-order list longer than its values")); + } + // The row each element belongs to: `offsets[r]..offsets[r+1]`. + let mut rows_of: Vec = Vec::with_capacity(total); + for r in 0..rows { + let (start, stop) = (at(r)?, at(r.checked_add(1).ok_or_else(|| too_many(rows))?)?); + rows_of.extend(std::iter::repeat_n( + u32::try_from(r).map_err(|_| too_many(rows))?, + stop - start, + )); + } + let rows_of = UInt32Array::from(rows_of); + let mut columns: Vec = Vec::with_capacity(self.sources.len()); + for source in &self.sources { + columns.push(match source { + // A root column, or an enclosing flattened batch's column + // for a nested call: repeated per element. + Source::Root(index) => { + let values = Arc::clone(batch.column(*index)); + arrow_select::take::take(values.as_ref(), &rows_of, None) + .map_err(|e| internal(&e.to_string()))? + } + Source::Element => list.values().slice(0, total), + Source::Index => { + let mut at_vals: Vec = Vec::with_capacity(total); + for r in 0..rows { + let next = r.checked_add(1).ok_or_else(|| too_many(rows))?; + let len = at(next)? - at(r)?; + at_vals.extend(0..i32::try_from(len).map_err(|_| too_many(len))?); + } + Arc::new(Int32Array::from(at_vals)) + } + }); + } + let flat = if columns.is_empty() { + // A body that reads nothing (a constant lambda) still needs + // `total` rows to evaluate over; it ignores the column. + RecordBatch::try_new( + Arc::new(Schema::new(vec![Field::new("c0", ArrowType::Null, true)])), + vec![Arc::new(arrow_array::NullArray::new(total)) as ArrayRef], + ) + .map_err(|e| internal(&e.to_string()))? + } else { + RecordBatch::try_new( + Arc::new(Schema::new( + columns + .iter() + .enumerate() + .map(|(i, c)| Field::new(format!("c{i}"), c.data_type().clone(), true)) + .collect::>(), + )), + columns, + ) + .map_err(|e| internal(&e.to_string()))? + }; + let body = self.body.eval(&flat)?.into_array(total)?; + if body.len() != total { + return Err(internal("a higher-order body of the wrong row count")); + } + let out = match self.name.as_str() { + "transform" => { + let ArrowType::List(field) = &self.out else { + return Err(internal("a higher-order call over a non-list")); + }; + Arc::new( + list::transform_list(list, &body, field.is_nullable()) + .map_err(|e| internal(&e.to_string()))?, + ) as ArrayRef + } + "filter" | "exists" | "forall" => { + let keep = body + .as_boolean_opt() + .ok_or_else(|| internal("a higher-order predicate that is no boolean array"))?; + if self.name == "filter" { + Arc::new(list::filter_list(list, keep).map_err(|e| internal(&e.to_string()))?) + as ArrayRef + } else if self.name == "exists" { + Arc::new(list::exists_list(list, keep).map_err(|e| internal(&e.to_string()))?) + as ArrayRef + } else { + Arc::new(list::forall_list(list, keep).map_err(|e| internal(&e.to_string()))?) + as ArrayRef + } + } + _ => return Err(unsupported(&format!("higher-order function {}", self.name))), + }; + if out.data_type() != &self.out { + return Err(internal(&format!( + "{} returned {} where the analyzer typed {}", + self.name, + out.data_type(), + self.out + ))); + } + Ok(Value::Array(out)) + } +} diff --git a/crates/krishiv-exec/src/planner/eval/mod.rs b/crates/krishiv-exec/src/planner/eval/mod.rs index 9d6510f25..b88fd505c 100644 --- a/crates/krishiv-exec/src/planner/eval/mod.rs +++ b/crates/krishiv-exec/src/planner/eval/mod.rs @@ -26,6 +26,7 @@ mod arith; mod cast; mod cond; mod func; +mod hof; mod logic; mod nested_cast; mod strings; @@ -247,9 +248,31 @@ pub(crate) fn compile(e: &Expr, input: Input<'_>) -> Result> { nullable: field.is_nullable(), })) } + // A lambda variable: a column of the flattened batch the + // higher-order call compiled around the body (see `hof`). + ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => { + let index = input + .layout + .iter() + .position(|a| *a == c.id) + .ok_or_else(|| { + internal(&format!("attribute #{} is not an input column", c.id.0)) + })?; + let field = input.schema.field(index); + Ok(Arc::new(Column { + index, + data_type: field.data_type().clone(), + nullable: field.is_nullable(), + })) + } ExprNode::Resolved(ResolvedExpr::Alias { expr, .. }) => compile(expr, input), ExprNode::Cast { expr, to, mode } => cast::compile(compile(expr, input)?, to, *mode, input), ExprNode::Resolved(ResolvedExpr::Function(f)) if f.kind == FunctionKind::Scalar => { + if let FunctionId::Registry { name, .. } = &f.id + && hof::is_supported(name) + { + return hof::compile(name, f, input, e); + } let args = f .args .iter() diff --git a/crates/krishiv-functions/src/python_wrappers/table.rs b/crates/krishiv-functions/src/python_wrappers/table.rs index c6c950a9c..a8312ddf9 100644 --- a/crates/krishiv-functions/src/python_wrappers/table.rs +++ b/crates/krishiv-functions/src/python_wrappers/table.rs @@ -34,6 +34,22 @@ pub(super) const NOT_EXPORTED: &[(&str, &str)] = &[ "pow", "an alias of `power`; the exported `pow` is a row that sends `power`", ), + ( + "transform", + "takes a lambda; the Python `Column` API cannot build lambdas yet", + ), + ( + "filter", + "takes a lambda; the Python `Column` API cannot build lambdas yet", + ), + ( + "exists", + "takes a lambda; the Python `Column` API cannot build lambdas yet", + ), + ( + "forall", + "takes a lambda; the Python `Column` API cannot build lambdas yet", + ), ]; /// Registry names whose wrapper is written by hand in `functions.py`. @@ -207,7 +223,7 @@ pub(super) fn rows() -> Vec { "col: ColumnOrName, ignoreNulls: bool | Column = None", )); } - for name in ["coalesce", "hash", "xxhash64"] { + for name in ["array", "coalesce", "hash", "xxhash64"] { rows.push(Row::new(name, "*cols: ColumnOrName")); } for name in ["lpad", "rpad"] { diff --git a/crates/krishiv-functions/src/registry/defs.rs b/crates/krishiv-functions/src/registry/defs.rs index f46573e89..e08f2d21a 100644 --- a/crates/krishiv-functions/src/registry/defs.rs +++ b/crates/krishiv-functions/src/registry/defs.rs @@ -818,5 +818,6 @@ pub(super) fn specs() -> Vec { out.extend(super::bitwise::specs()); out.extend(super::predicate::specs()); out.extend(super::number::specs()); + out.extend(super::hof::specs()); out } diff --git a/crates/krishiv-functions/src/registry/hof.rs b/crates/krishiv-functions/src/registry/hof.rs new file mode 100644 index 000000000..8f876ef51 --- /dev/null +++ b/crates/krishiv-functions/src/registry/hof.rs @@ -0,0 +1,173 @@ +// SPDX-License-Identifier: Apache-2.0 +//! The analysis signatures of the higher-order functions over arrays +//! (`transform`, `filter`, `exists`, `forall`) and the `array` +//! constructor they need (Spark's `ArrayHigherOrderFunction`s and +//! `CreateArray`). +//! +//! The analyzer binds a lambda's variables before the generic path types +//! the call (see `krishiv-plan`'s `hof`): at a lambda position the +//! argument's type is its body's, so these rules read the body type from +//! the argument. The executor compiles the bodies (see `krishiv-exec`'s +//! `hof`); only `array` binds a kernel here. +//! +//! `array` is the minimal constructor this family needs (all arguments at +//! their common type, as Spark's `CreateArray` types them). The collection +//! functions own its completion (nested coercion edge cases). + +use krishiv_common::error::{DatatypeMismatchUnexpectedInputType, InternalError, KrishivError}; +use krishiv_types::{ArrayType, DataType}; + +use super::Execution; +use super::defs::Spec; +use crate::signature::{ArgType, CallTypes, FunctionKind, Inputs}; + +/// `array(...)`: an array of the arguments' common type (Spark's +/// `CreateArray`; untyped `NULL` is `VOID`). The analyzer casts the +/// arguments to their common type first. +fn array_result(c: &CallTypes<'_>) -> Result { + let element = c.args().first().and_then(|a| a.data_type.clone()); + let nullable = c.args().iter().any(|a| a.nullable); + Ok(ArgType::new( + DataType::Array(ArrayType::new(element.unwrap_or(DataType::Null), nullable).into()), + false, + )) +} + +/// The call's SQL as Spark quotes it in errors: `name(arg, ...)`. +fn call_sql(name: &str, c: &CallTypes<'_>) -> String { + let args: Vec = (0..c.args().len()) + .map(|i| c.sql(i).unwrap_or_default()) + .collect(); + format!("\"{name}({})\"", args.join(", ")) +} + +/// A type as Spark's message parameters quote it (`"VOID"` for untyped +/// `NULL`). +fn quoted(t: Option<&DataType>) -> String { + format!("\"{}\"", t.map_or_else(|| "VOID".to_owned(), DataType::sql)) +} + +/// The array argument's element type, `containsNull` and nullability, or +/// the `UNEXPECTED_INPUT_TYPE` error quoting it (Spark's +/// `checkInputDataTypes`). The arity check runs before typing, so a +/// missing argument is an internal error. +fn array_argument(name: &str, c: &CallTypes<'_>) -> Result<(DataType, bool, bool), KrishivError> { + let Some(arg) = c.args().first() else { + return Err(InternalError { + message: format!("{name} typed without its array argument"), + } + .into()); + }; + match &arg.data_type { + Some(DataType::Array(element)) => Ok(( + element.element_type().clone(), + element.contains_null(), + arg.nullable, + )), + other => Err(DatatypeMismatchUnexpectedInputType { + sql_expr: call_sql(name, c), + param_index: "first".to_owned(), + required_type: "\"ARRAY\"".to_owned(), + input_sql: format!("\"{}\"", c.sql(0).unwrap_or_default()), + input_type: quoted(other.as_ref()), + } + .into()), + } +} + +/// Whether the lambda body (the second argument's type) is boolean, or the +/// `UNEXPECTED_INPUT_TYPE` error quoting it (Spark quotes the lambda, +/// constant lambdas wrapped over their hidden variable by the analyzer). +fn boolean_body(name: &str, c: &CallTypes<'_>) -> Result { + let body = c.args().get(1); + match body.and_then(|a| a.data_type.as_ref()) { + Some(DataType::Boolean) => Ok(body.is_some_and(|a| a.nullable)), + other => Err(DatatypeMismatchUnexpectedInputType { + sql_expr: call_sql(name, c), + param_index: "second".to_owned(), + required_type: "\"BOOLEAN\"".to_owned(), + input_sql: c.sql(1).unwrap_or_default(), + input_type: quoted(other), + } + .into()), + } +} + +/// `transform(arr, f)`: an array of the body's type. +fn transform_result(c: &CallTypes<'_>) -> Result { + let (_, _, nullable) = array_argument("transform", c)?; + let body = c.args().get(1); + let element = body + .and_then(|a| a.data_type.clone()) + .unwrap_or(DataType::Null); + let contains_null = body.is_none_or(|a| a.nullable); + Ok(ArgType::new( + DataType::Array(ArrayType::new(element, contains_null).into()), + nullable, + )) +} + +/// `filter(arr, p)`: the array itself, with a boolean body. +fn filter_result(c: &CallTypes<'_>) -> Result { + let (element, contains_null, nullable) = array_argument("filter", c)?; + let _ = boolean_body("filter", c)?; + Ok(ArgType::new( + DataType::Array(ArrayType::new(element, contains_null).into()), + nullable, + )) +} + +/// `exists(arr, p)`: a boolean, with a boolean body. +fn exists_result(c: &CallTypes<'_>) -> Result { + let (_, _, nullable) = array_argument("exists", c)?; + let _ = boolean_body("exists", c)?; + Ok(ArgType::new(DataType::Boolean, nullable)) +} + +/// `forall(arr, p)`: a boolean, with a boolean body. +fn forall_result(c: &CallTypes<'_>) -> Result { + let (_, _, nullable) = array_argument("forall", c)?; + let _ = boolean_body("forall", c)?; + Ok(ArgType::new(DataType::Boolean, nullable)) +} + +/// The signatures of this family. +pub(super) fn specs() -> Vec { + vec![ + Spec { + name: "array", + kind: FunctionKind::Scalar, + inputs: Inputs::Common, + result: array_result, + execution: Execution::Scalar, + }, + Spec { + name: "transform", + kind: FunctionKind::Scalar, + inputs: Inputs::Any, + result: transform_result, + execution: Execution::HigherOrder, + }, + Spec { + name: "filter", + kind: FunctionKind::Scalar, + inputs: Inputs::Any, + result: filter_result, + execution: Execution::HigherOrder, + }, + Spec { + name: "exists", + kind: FunctionKind::Scalar, + inputs: Inputs::Any, + result: exists_result, + execution: Execution::HigherOrder, + }, + Spec { + name: "forall", + kind: FunctionKind::Scalar, + inputs: Inputs::Any, + result: forall_result, + execution: Execution::HigherOrder, + }, + ] +} diff --git a/crates/krishiv-functions/src/registry/mod.rs b/crates/krishiv-functions/src/registry/mod.rs index da1b6b7a9..bfa7dd4a1 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 hof; mod math; mod number; mod predicate; @@ -46,6 +47,11 @@ pub enum Execution { /// By the executor's window operator, over a window (`row_number`, /// `rank`, ...); never called without `OVER`. Window, + /// By the executor's higher-order compiler, which evaluates the lambda + /// bodies: `transform`, `filter`, `exists`, `forall` + /// (`krishiv_exec::planner::eval::hof`, over `krishiv_kernels::list`). + /// A lambda is no Arrow value, so these never bind a kernel here. + HigherOrder, } /// The aggregates the executor implements. diff --git a/crates/krishiv-functions/src/registry/tests.rs b/crates/krishiv-functions/src/registry/tests.rs index 669337917..c4ef0fdc0 100644 --- a/crates/krishiv-functions/src/registry/tests.rs +++ b/crates/krishiv-functions/src/registry/tests.rs @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 use krishiv_common::error::{ErrorClass, KrishivError}; -use krishiv_types::{DataType, DecimalType}; +use krishiv_types::{ArrayType, DataType, DecimalType}; use super::{Aggregate, Execution, FunctionDef, Lookup, builtins}; use crate::scalar::scalar_names; @@ -1518,3 +1518,77 @@ fn regex_signatures() { let r = result("regexp_count", &[s, null_ty()], &[]).unwrap(); assert_eq!(r, ArgType::new(DataType::Integer, true)); } + +#[test] +fn hof_signatures() { + use DataType::{Array, Boolean, Integer}; + let array = |e: DataType, contains_null: bool, nullable: bool| { + ArgType::new(Array(ArrayType::new(e, contains_null).into()), nullable) + }; + let i = || ty(Integer); + let b = || ty(Boolean); + // `array(...)`: the common element type; untyped `NULL` is `VOID`, + // no arguments an empty `VOID` array. + assert_eq!( + result("array", &[i(), i()], &[]).unwrap(), + array(Integer, false, false) + ); + assert_eq!( + result("array", &[ArgType::new(Integer, true), i()], &[]).unwrap(), + array(Integer, true, false) + ); + assert_eq!( + result("array", &[null_ty(), null_ty()], &[]).unwrap(), + array(DataType::Null, true, false) + ); + assert_eq!( + result("array", &[], &[]).unwrap(), + array(DataType::Null, false, false) + ); + // The higher-order functions type their lambda argument as its body: + // `transform` maps the body, `filter` keeps the array, `exists` and + // `forall` fold to booleans. + let arr = || array(Integer, true, false); + assert_eq!( + result("transform", &[arr(), i()], &[]).unwrap(), + array(Integer, false, false) + ); + assert_eq!( + result("transform", &[arr(), ArgType::new(Integer, true)], &[]).unwrap(), + array(Integer, true, false) + ); + assert_eq!(result("filter", &[arr(), b()], &[]).unwrap(), arr()); + assert_eq!( + result("exists", &[array(Integer, false, true), b()], &[]).unwrap(), + ArgType::new(Boolean, true) + ); + assert_eq!( + result("forall", &[arr(), b()], &[]).unwrap(), + ArgType::new(Boolean, false) + ); + // The array comes first and holds an array; the predicate is boolean. + for name in ["transform", "filter", "exists", "forall"] { + let err = result(name, &[i(), i()], &[]).unwrap_err(); + assert_eq!( + err.error_class(), + ErrorClass::DatatypeMismatchUnexpectedInputType, + "{name}" + ); + assert!(err.to_string().contains("\"ARRAY\""), "{name}: {err}"); + } + for name in ["filter", "exists", "forall"] { + let err = result(name, &[arr(), i()], &[]).unwrap_err(); + assert_eq!( + err.error_class(), + ErrorClass::DatatypeMismatchUnexpectedInputType, + "{name}" + ); + assert!(err.to_string().contains("\"BOOLEAN\""), "{name}: {err}"); + } + // Higher-order calls run in the executor, never in a kernel binding. + for name in ["transform", "filter", "exists", "forall"] { + assert_eq!(def(name).execution, Execution::HigherOrder, "{name}"); + assert_eq!(def(name).kind, FunctionKind::Scalar, "{name}"); + } + assert_eq!(def("array").execution, Execution::Scalar); +} diff --git a/crates/krishiv-functions/src/scalar/array.rs b/crates/krishiv-functions/src/scalar/array.rs new file mode 100644 index 000000000..561d620b7 --- /dev/null +++ b/crates/krishiv-functions/src/scalar/array.rs @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: Apache-2.0 +//! The `array(...)` constructor: one list per row holding each argument's +//! value (Spark's `CreateArray`). The analyzer casts the arguments to +//! their common type first; the kernel interleaves them (see +//! `krishiv_kernels::list::create`). + +use std::sync::Arc; + +use arrow_array::ArrayRef; +use arrow_schema::DataType; +use krishiv_kernels::list; + +use super::args::Inputs; +use super::{BindArg, BindOptions, Binding, FamilyResult, bad_types, listed}; + +/// Every name this family binds. +pub(super) const NAMES: &[&str] = &["array"]; + +/// `array(a, b, ...)`: the arguments share one type (checked here, as the +/// analyzer's common cast may leave an untyped `NULL` they all share). +/// No arguments is an empty list per row (Spark's `array()`). +fn array(args: &[BindArg]) -> Option { + let first = args + .first() + .map(BindArg::data_type) + .unwrap_or(DataType::Null); + if args.iter().any(|a| a.data_type() != first) { + return None; + } + let contains_null = args.iter().any(BindArg::nullable); + let return_type = DataType::List(Arc::new(arrow_schema::Field::new( + "element", + first, + contains_null, + ))); + let n = args.len(); + Some(Binding::new(return_type, move |x: &Inputs<'_>| { + let mut args = Vec::with_capacity(n); + for i in 0..n { + args.push(x.column(i)?); + } + Ok(Arc::new(list::create(&args, x.rows(), contains_null)?) as ArrayRef) + })) +} + +/// Binds the constructor. +pub(super) fn bind(name: &str, args: &[BindArg], opts: &BindOptions) -> FamilyResult { + let _ = opts; + let listed = listed(NAMES, name)?; + match array(args) { + Some(b) => Some((listed, Ok(b))), + None => Some((listed, Err(bad_types(listed, args)))), + } +} diff --git a/crates/krishiv-functions/src/scalar/mod.rs b/crates/krishiv-functions/src/scalar/mod.rs index def9ab20c..7aa7464c6 100644 --- a/crates/krishiv-functions/src/scalar/mod.rs +++ b/crates/krishiv-functions/src/scalar/mod.rs @@ -25,6 +25,7 @@ mod args; mod arith; +mod array; mod bitwise; mod datetime; mod hash; @@ -53,8 +54,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; `nullable` is the analyzer's nullability + /// (a nested field's `nullable` is part of its Arrow type, so + /// constructors of nested values read it). + Column { + /// The value's Arrow type. + data_type: DataType, + /// Whether the value 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 +73,29 @@ 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 analyzer's nullability for a + /// column, the array's for a literal (an untyped `NULL` literal is + /// always null: its `NullArray` carries no validity bitmap). + #[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, + } } } @@ -283,7 +305,8 @@ 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] = [ + (array::NAMES, array::bind), (string::NAMES, string::bind), (datetime::NAMES, datetime::bind), (math::NAMES, math::bind), diff --git a/crates/krishiv-functions/src/scalar/regex/tests.rs b/crates/krishiv-functions/src/scalar/regex/tests.rs index 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/mod.rs b/crates/krishiv-functions/src/scalar/tests/mod.rs index 2c9ce543c..30df83834 100644 --- a/crates/krishiv-functions/src/scalar/tests/mod.rs +++ b/crates/krishiv-functions/src/scalar/tests/mod.rs @@ -579,7 +579,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", &[DataType::Int32.into()], &opts).is_err()); // `localtimestamp` is the wall clock of the session zone, without a zone. let micros = 1_700_000_000_123_456; let opts = BindOptions::new() diff --git a/crates/krishiv-kernels/Cargo.toml b/crates/krishiv-kernels/Cargo.toml index 1472d490c..4389323b5 100644 --- a/crates/krishiv-kernels/Cargo.toml +++ b/crates/krishiv-kernels/Cargo.toml @@ -15,6 +15,7 @@ workspace = true arrow-array.workspace = true arrow-buffer.workspace = true arrow-schema.workspace = true +arrow-select.workspace = true krishiv-common = { path = "../krishiv-common" } libm.workspace = true md5.workspace = true diff --git a/crates/krishiv-kernels/src/lib.rs b/crates/krishiv-kernels/src/lib.rs index 517fdc93f..3c0877873 100644 --- a/crates/krishiv-kernels/src/lib.rs +++ b/crates/krishiv-kernels/src/lib.rs @@ -48,6 +48,7 @@ pub mod error; pub mod float; pub mod hash; pub mod integer; +pub mod list; pub mod math; pub mod number_format; pub mod ops; diff --git a/crates/krishiv-kernels/src/list.rs b/crates/krishiv-kernels/src/list.rs new file mode 100644 index 000000000..95e6b3e15 --- /dev/null +++ b/crates/krishiv-kernels/src/list.rs @@ -0,0 +1,274 @@ +// SPDX-License-Identifier: Apache-2.0 +//! List kernels for the higher-order functions: `array` builds a list per +//! row, and `transform` / `filter` / `exists` / `forall` consume one (see +//! `krishiv-exec`'s `hof`, which evaluates the lambda bodies). +//! +//! Every kernel works on the [`ListArray`] directly, offsets and child +//! values, never one Rust value per row: the caller evaluates a lambda +//! body once over the flattened child values, and these kernels only +//! reshape. A NULL list stays NULL; an empty list stays empty (or is +//! false for `exists`, true for `forall`). +//! +//! Offsets and lengths cross the `i32`/`u32`/`usize` boundary with checked +//! conversions: a batch that does not fit is an engine error, never a +//! wrap. + +use std::sync::Arc; + +use arrow_array::{Array, ArrayRef, BooleanArray, ListArray, NullArray}; +use arrow_buffer::{OffsetBuffer, ScalarBuffer}; +use arrow_schema::{DataType, Field}; + +use super::error::KernelError; + +/// The offsets of `list`, as `usize` pairs. +/// +/// # Errors +/// [`KernelError`] when an offset does not fit. +fn ranges(list: &ListArray) -> Result, KernelError> { + let offsets = list.value_offsets(); + let mut out = Vec::with_capacity(list.len()); + for pair in offsets.windows(2) { + let (start, stop) = (pair[0], pair[1]); + out.push(( + usize::try_from(start).map_err(|_| bad_offset(start))?, + usize::try_from(stop).map_err(|_| bad_offset(stop))?, + )); + } + return Ok(out); + + fn bad_offset(o: i32) -> KernelError { + KernelError::internal(format!("a list offset of {o}")) + } +} + +/// `array(a, b, ...)`: one list per row holding each argument's value +/// (`[a[r], b[r], ...]`), the values interleaved by one `take` over the +/// concatenated arguments. An empty argument list is an empty list per +/// row. The arguments share one type (the analyzer casts them); +/// `contains_null` is whether elements may be null (the analyzer's, from +/// the arguments' nullability). +/// +/// # Errors +/// [`KernelError`] when the arguments' lengths disagree with `rows`, or a +/// length does not fit a 32-bit offset. +pub fn create( + args: &[ArrayRef], + rows: usize, + contains_null: bool, +) -> Result { + for a in args { + if a.len() != rows { + return Err(KernelError::internal(format!( + "array of {rows} rows over an argument of {} rows", + a.len() + ))); + } + } + let len = list_len(rows, args.len())?; + if args.is_empty() { + let zeros = usize::checked_add(rows, 1).ok_or_else(|| too_big(rows))?; + let offsets = OffsetBuffer::new(ScalarBuffer::from(vec![0_i32; zeros])); + let values = NullArray::new(0); + return Ok(ListArray::new( + Arc::new(Field::new("element", DataType::Null, contains_null)), + offsets, + Arc::new(values), + None, + )); + } + let refs: Vec<&dyn Array> = args.iter().map(AsRef::as_ref).collect(); + let joined = + arrow_select::concat::concat(&refs).map_err(|e| KernelError::internal(e.to_string()))?; + // Row `r` takes element `r` of each argument: argument `c` starts at + // `c * rows` in the concatenation. + let stride = u32::try_from(rows).map_err(|_| too_big(rows))?; + let per_arg = u32::try_from(args.len()).map_err(|_| too_big(args.len()))?; + let mut take: Vec = Vec::with_capacity(len); + for r in 0..stride { + for c in 0..per_arg { + take.push( + c.checked_mul(stride) + .and_then(|at| at.checked_add(r)) + .ok_or_else(|| too_big(rows))?, + ); + } + } + let values = + arrow_select::take::take(joined.as_ref(), &arrow_array::UInt32Array::from(take), None) + .map_err(|e| KernelError::internal(e.to_string()))?; + let per_row = i32::try_from(args.len()).map_err(|_| too_big(args.len()))?; + let mut offsets = Vec::with_capacity(usize::checked_add(rows, 1).ok_or_else(|| too_big(rows))?); + for r in 0..=i32::try_from(rows).map_err(|_| too_big(rows))? { + offsets.push(r.checked_mul(per_row).ok_or_else(|| too_big(rows))?); + } + let field = Arc::new(Field::new( + "element", + values.data_type().clone(), + contains_null, + )); + Ok(ListArray::new( + field, + OffsetBuffer::new(ScalarBuffer::from(offsets)), + values, + None, + )) +} + +/// What does not fit a 32-bit offset or index. +fn too_big(n: usize) -> KernelError { + KernelError::internal(format!("a list of {n} rows")) +} + +/// `rows` lists of `per_row` elements: their interleaved length. +/// +/// # Errors +/// [`KernelError`] when the length does not fit. +fn list_len(rows: usize, per_row: usize) -> Result { + rows.checked_mul(per_row.max(1)) + .ok_or_else(|| too_big(rows)) +} + +/// `transform(list, values)`: the lists of `list` over the new child +/// `values` (the body evaluated over the flattened elements). `values` +/// holds one entry per element of `list`; `contains_null` is the body's +/// nullability. +/// +/// # Errors +/// [`KernelError`] when `values` is shorter than the elements. +pub fn transform_list( + list: &ListArray, + values: &ArrayRef, + contains_null: bool, +) -> Result { + let (_, end) = ranges(list)?.last().copied().unwrap_or((0, 0)); + if values.len() < end { + return Err(KernelError::internal(format!( + "transform over {end} elements with {} values", + values.len() + ))); + } + let values = if values.len() == end { + Arc::clone(values) + } else { + values.slice(0, end) + }; + let field = Arc::new(Field::new( + "element", + values.data_type().clone(), + contains_null, + )); + Ok(ListArray::new( + field, + list.offsets().clone(), + values, + list.nulls().cloned(), + )) +} + +/// `filter(list, keep)`: the elements `keep` marks true (a NULL mark drops +/// its element, as Spark does). `keep` holds one entry per element of +/// `list`. +/// +/// # Errors +/// [`KernelError`] when `keep` is shorter than the elements, or the kept +/// length does not fit a 32-bit offset. +pub fn filter_list(list: &ListArray, keep: &BooleanArray) -> Result { + let ranges = ranges(list)?; + let (_, end) = ranges.last().copied().unwrap_or((0, 0)); + if keep.len() < end { + return Err(KernelError::internal(format!( + "filter over {end} elements with {} marks", + keep.len() + ))); + } + let mut take: Vec = Vec::with_capacity(end); + let mut offsets = Vec::with_capacity( + usize::checked_add(list.len(), 1) + .ok_or_else(|| KernelError::internal(format!("a filter over {} lists", list.len())))?, + ); + offsets.push(0_i32); + for (i, &(start, stop)) in ranges.iter().enumerate() { + if list.is_null(i) { + offsets.push(i32::try_from(take.len()).map_err(|_| too_big(take.len()))?); + continue; + } + for e in start..stop { + if keep.is_valid(e) && keep.value(e) { + take.push(u32::try_from(e).map_err(|_| too_big(e))?); + } + } + offsets.push(i32::try_from(take.len()).map_err(|_| too_big(take.len()))?); + } + let values = arrow_select::take::take( + list.values().as_ref(), + &arrow_array::UInt32Array::from(take), + None, + ) + .map_err(|e| KernelError::internal(e.to_string()))?; + // The elements pass through unchanged: the field rides along. + let field = Arc::clone(list.value_field()); + Ok(ListArray::new( + field, + OffsetBuffer::new(ScalarBuffer::from(offsets)), + values, + list.nulls().cloned(), + )) +} + +/// Folds `keep` (one entry per element of `list`) to one boolean per list: +/// `any` is true when some mark is true, `all` is false when some mark is +/// false. NULL marks decide nothing either way (a NULL list stays NULL, +/// an empty one is `any = false`, `all = true`). +fn fold_flags( + list: &ListArray, + keep: &BooleanArray, + any: bool, +) -> Result { + let ranges = ranges(list)?; + let (_, end) = ranges.last().copied().unwrap_or((0, 0)); + if keep.len() < end { + return Err(KernelError::internal(format!( + "fold over {end} elements with {} marks", + keep.len() + ))); + } + let mut out = BooleanArray::builder(list.len()); + for (i, &(start, stop)) in ranges.iter().enumerate() { + if list.is_null(i) { + out.append_null(); + continue; + } + let mut hit = false; + for e in start..stop { + if !keep.is_valid(e) { + continue; + } + if keep.value(e) == any { + hit = true; + break; + } + } + out.append_value(if any { hit } else { !hit }); + } + Ok(out.finish()) +} + +/// `exists(list, keep)`: whether some element's mark is true. +/// +/// # Errors +/// [`KernelError`] when `keep` is shorter than the elements. +pub fn exists_list(list: &ListArray, keep: &BooleanArray) -> Result { + fold_flags(list, keep, true) +} + +/// `forall(list, keep)`: whether no element's mark is false. +/// +/// # Errors +/// [`KernelError`] when `keep` is shorter than the elements. +pub fn forall_list(list: &ListArray, keep: &BooleanArray) -> Result { + fold_flags(list, keep, false) +} + +#[cfg(test)] +mod tests; diff --git a/crates/krishiv-kernels/src/list/tests.rs b/crates/krishiv-kernels/src/list/tests.rs new file mode 100644 index 000000000..82234e402 --- /dev/null +++ b/crates/krishiv-kernels/src/list/tests.rs @@ -0,0 +1,250 @@ +// SPDX-License-Identifier: Apache-2.0 +//! Unit tests for the list kernels: nulls, empty lists, nested lists, +//! large offsets and precondition failures. + +use std::sync::Arc; + +use arrow_array::cast::AsArray; +use arrow_array::types::Int32Type; +use arrow_array::{Array, ArrayRef, BooleanArray, Int32Array, ListArray}; +use arrow_buffer::{NullBuffer, OffsetBuffer, ScalarBuffer}; +use arrow_schema::{DataType, Field}; + +use super::{create, exists_list, filter_list, forall_list, transform_list}; + +fn field() -> Arc { + Arc::new(Field::new("element", DataType::Int32, true)) +} + +fn list(values: &[Option>>]) -> ListArray { + let mut ints = Vec::new(); + let mut offsets = vec![0_i32]; + let mut nulls = Vec::new(); + for row in values { + match row { + None => { + nulls.push(false); + offsets.push(i32::try_from(ints.len()).unwrap()); + } + Some(items) => { + nulls.push(true); + for v in items { + ints.push(*v); + } + offsets.push(i32::try_from(ints.len()).unwrap()); + } + } + } + ListArray::new( + field(), + OffsetBuffer::new(ScalarBuffer::from(offsets)), + Arc::new(Int32Array::from(ints)), + Some(NullBuffer::from(nulls)), + ) +} + +fn marks(values: Vec>) -> BooleanArray { + values.into_iter().collect() +} + +fn flat(list: &ListArray) -> Vec> { + list.values().as_primitive::().iter().collect() +} + +fn rows(list: &ListArray) -> Vec>>> { + let values = flat(list); + let offsets = list.value_offsets(); + (0..list.len()) + .map(|i| { + if list.is_null(i) { + return None; + } + let next = i.checked_add(1).unwrap(); + let (start, stop) = ( + usize::try_from(offsets[i]).unwrap(), + usize::try_from(offsets[next]).unwrap(), + ); + Some(values[start..stop].to_vec()) + }) + .collect() +} + +#[test] +fn create_interleaves_columns() { + let a: ArrayRef = Arc::new(Int32Array::from(vec![Some(1), None, Some(3)])); + let b: ArrayRef = Arc::new(Int32Array::from(vec![Some(4), Some(5), None])); + let out = create(&[a, b], 3, true).unwrap(); + assert_eq!( + rows(&out), + vec![ + Some(vec![Some(1), Some(4)]), + Some(vec![None, Some(5)]), + Some(vec![Some(3), None]), + ] + ); +} + +#[test] +fn create_no_arguments_is_empty() { + let out = create(&[], 2, false).unwrap(); + assert_eq!(out.len(), 2); + assert_eq!(out.value_offsets(), &[0, 0, 0]); +} + +#[test] +fn create_rejects_a_short_argument() { + let a: ArrayRef = Arc::new(Int32Array::from(vec![1])); + assert!(create(&[a], 2, true).is_err()); +} + +#[test] +fn transform_rebuilds_over_new_values() { + // `[1, 2], NULL, [], [3]`, doubled to `[2, 4], NULL, [], [6]`. + let input = list(&[ + Some(vec![Some(1), Some(2)]), + None, + Some(vec![]), + Some(vec![Some(3)]), + ]); + let values: ArrayRef = Arc::new(Int32Array::from(vec![2, 4, 6])); + let out = transform_list(&input, &values, true).unwrap(); + assert_eq!( + rows(&out), + vec![ + Some(vec![Some(2), Some(4)]), + None, + Some(vec![]), + Some(vec![Some(6)]), + ] + ); + assert!(out.is_null(1)); +} + +#[test] +fn transform_rejects_short_values() { + let input = list(&[Some(vec![Some(1)])]); + let values: ArrayRef = Arc::new(Int32Array::new_null(0)); + assert!(transform_list(&input, &values, true).is_err()); +} + +#[test] +fn filter_drops_unmarked_elements() { + // `[1, NULL, 3], NULL, [], [4]`, keeping the first of each pair. + let input = list(&[ + Some(vec![Some(1), None, Some(3)]), + None, + Some(vec![]), + Some(vec![Some(4)]), + ]); + let keep = marks(vec![Some(true), None, Some(false), Some(true)]); + let out = filter_list(&input, &keep).unwrap(); + assert_eq!( + rows(&out), + vec![Some(vec![Some(1)]), None, Some(vec![]), Some(vec![Some(4)]),] + ); +} + +#[test] +fn filter_null_marks_drop() { + let input = list(&[Some(vec![Some(1), Some(2)])]); + let keep = marks(vec![None, None]); + let out = filter_list(&input, &keep).unwrap(); + assert_eq!(rows(&out), vec![Some(vec![])]); +} + +#[test] +fn filter_rejects_short_marks() { + let input = list(&[Some(vec![Some(1), Some(2)])]); + assert!(filter_list(&input, &marks(vec![Some(true)])).is_err()); +} + +#[test] +fn exists_folds_any_true() { + let input = list(&[ + Some(vec![Some(1), None]), + Some(vec![None, None]), + None, + Some(vec![]), + ]); + // Marks: row 0 has a true, row 1 only nulls, row 3 is empty. + let keep = marks(vec![Some(false), None, None, None]); + let out = exists_list(&input, &keep).unwrap(); + let got: Vec> = out.iter().collect(); + assert_eq!(got, vec![Some(false), Some(false), None, Some(false)]); + let keep = marks(vec![Some(true), None, None, None]); + let out = exists_list(&input, &keep).unwrap(); + let got: Vec> = out.iter().collect(); + assert_eq!(got, vec![Some(true), Some(false), None, Some(false)]); +} + +#[test] +fn forall_folds_no_false() { + let input = list(&[ + Some(vec![Some(1), None]), + Some(vec![None]), + None, + Some(vec![]), + ]); + // NULL marks decide nothing: row 0 is all-true, row 1 vacuous. + let keep = marks(vec![Some(true), None, None]); + let out = forall_list(&input, &keep).unwrap(); + let got: Vec> = out.iter().collect(); + assert_eq!(got, vec![Some(true), Some(true), None, Some(true)]); + let keep = marks(vec![Some(true), Some(false), None]); + let out = forall_list(&input, &keep).unwrap(); + let got: Vec> = out.iter().collect(); + assert_eq!(got, vec![Some(false), Some(true), None, Some(true)]); +} + +#[test] +fn fold_rejects_short_marks() { + let input = list(&[Some(vec![Some(1)])]); + let keep = marks(vec![]); + assert!(exists_list(&input, &keep).is_err()); + assert!(forall_list(&input, &keep).is_err()); +} + +#[test] +fn nested_lists_reshape() { + // `[[1, 2], [3]]`: filtering the single outer row's elements keeps + // whole inner lists, like any other element. + let inner = list(&[Some(vec![Some(1), Some(2)]), Some(vec![Some(3)])]); + let outer = ListArray::new( + Arc::new(Field::new("element", DataType::List(field()), true)), + OffsetBuffer::new(ScalarBuffer::from(vec![0, 2])), + Arc::new(inner), + None, + ); + let keep = marks(vec![Some(false), Some(true)]); + let out = filter_list(&outer, &keep).unwrap(); + assert_eq!(out.len(), 1); + assert_eq!(out.value_offsets(), &[0, 1]); + let kept: &ListArray = out.values().as_list::(); + assert_eq!(kept.len(), 1); + assert_eq!(kept.value_offsets(), &[0, 1]); + assert_eq!(flat(kept), vec![Some(3)]); +} + +#[test] +fn large_offsets_reshape() { + // 100,000 single-element lists: the reshape is offset arithmetic. + let n = 100_000usize; + let values: ArrayRef = Arc::new(Int32Array::from(vec![1; n])); + let input = ListArray::new( + field(), + OffsetBuffer::new(ScalarBuffer::from_iter(0..=i32::try_from(n).unwrap())), + values, + None, + ); + let doubled: ArrayRef = Arc::new(Int32Array::from(vec![2; n])); + let out = transform_list(&input, &doubled, false).unwrap(); + assert_eq!(out.len(), n); + assert_eq!(usize::try_from(out.value_offsets()[n]).unwrap(), n); + let keep = BooleanArray::from(vec![true; n]); + let out = filter_list(&input, &keep).unwrap(); + assert_eq!(usize::try_from(out.value_offsets()[n]).unwrap(), n); + let out = exists_list(&input, &keep).unwrap(); + assert!(out.iter().all(|v| v == Some(true))); + let out = forall_list(&input, &keep).unwrap(); + assert!(out.iter().all(|v| v == Some(true))); +} diff --git a/crates/krishiv-plan-codec/src/decode.rs b/crates/krishiv-plan-codec/src/decode.rs index 7ba9cb913..2f4901eec 100644 --- a/crates/krishiv-plan-codec/src/decode.rs +++ b/crates/krishiv-plan-codec/src/decode.rs @@ -335,8 +335,10 @@ fn expr_children(m: &pb::Expr) -> impl Iterator + '_ { let (one, many): (Option, &[u32]) = match &m.kind { Some(Kind::Cast(c)) => (Some(c.expr), &[]), Some(Kind::Alias(a)) => (Some(a.expr), &[]), + Some(Kind::Lambda(l)) => (Some(l.body), &[]), Some(Kind::Function(f)) => (f.filter, &f.args), - Some(Kind::Literal(_) | Kind::Column(_) | Kind::OuterColumn(_)) | None => (None, &[]), + Some(Kind::Literal(_) | Kind::Column(_) | Kind::OuterColumn(_) | Kind::LambdaVar(_)) + | None => (None, &[]), }; one.into_iter().chain(many.iter().copied()) } @@ -631,6 +633,11 @@ impl Decoder { Kind::Literal(l) => ExprNode::Literal(literal(l)?), Kind::Column(c) => ExprNode::Resolved(ResolvedExpr::Column(bound_column(c)?)), Kind::OuterColumn(c) => ExprNode::Resolved(ResolvedExpr::OuterColumn(bound_column(c)?)), + Kind::LambdaVar(c) => ExprNode::Resolved(ResolvedExpr::LambdaVar(bound_column(c)?)), + Kind::Lambda(l) => ExprNode::Lambda { + params: l.params.clone(), + body: self.expr_ref(l.body)?, + }, Kind::Cast(c) => ExprNode::Cast { expr: self.expr_ref(c.expr)?, to: spark_type(required(&c.to, "a cast type")?)?, diff --git a/crates/krishiv-plan-codec/src/encode.rs b/crates/krishiv-plan-codec/src/encode.rs index 8c20272f8..c466c8bf2 100644 --- a/crates/krishiv-plan-codec/src/encode.rs +++ b/crates/krishiv-plan-codec/src/encode.rs @@ -472,6 +472,13 @@ impl Encoder { ExprNode::Resolved(ResolvedExpr::OuterColumn(c)) => { Kind::OuterColumn(bound_column(c, &self.nested)?) } + ExprNode::Lambda { params, body } => Kind::Lambda(pb::Lambda { + params: params.clone(), + body: self.child(body), + }), + ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => { + Kind::LambdaVar(bound_column(c, &self.nested)?) + } ExprNode::Resolved(ResolvedExpr::Function(f)) => Kind::Function(self.function(f)?), ExprNode::Resolved(ResolvedExpr::Alias { expr, output }) => { Kind::Alias(pb::AliasExpr { diff --git a/crates/krishiv-plan-codec/src/features.rs b/crates/krishiv-plan-codec/src/features.rs index b714aee78..703927c58 100644 --- a/crates/krishiv-plan-codec/src/features.rs +++ b/crates/krishiv-plan-codec/src/features.rs @@ -119,6 +119,7 @@ macro_rules! registry { 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`)."), + (lambda_functions, LambdaFunctions, POST_MIGRATION_READER_VERSION, Semantic, "Lambda expressions (`x -> body`) and variables: the bound bodies of higher-order function arguments (`transform`, `filter`, `exists`, `forall`)."), (limit_offset, LimitOffset, 3, Semantic, "A `Limit` that skips leading rows (a nonzero offset)."), (nested_types, NestedTypes, POST_MIGRATION_READER_VERSION, Semantic, "Array, map and struct types (`DataType.KIND_NESTED`, written as Spark's JSON form of the type)."), (window, Window, 4, Semantic, "The `Window` node and its functions."), @@ -168,6 +169,9 @@ pub enum Construct<'a> { /// a subquery's value, a runtime filter's key, a window offset function's /// value, the plan's output schema). ArrowType(&'a arrow_schema::DataType), + /// A lambda expression or variable: the bound body of a higher-order + /// function's argument. + Lambda, } /// Whether an Arrow type is or contains an array, map or struct. @@ -250,6 +254,9 @@ pub fn feature_of(construct: Construct<'_>) -> Option { Some(Feature::WindowOffsetFunctions) } }, + // A lambda is plan data behind its own feature: a reader without + // it misreads the higher-order call's argument. + Construct::Lambda => Some(Feature::LambdaFunctions), // A type Krishiv does not know cannot be encoded at all. A later // feature for a type that can sit inside an array, map or struct // (variant, char/varchar, intervals) must look through them: its @@ -328,6 +335,68 @@ fn constructs_of<'a>(node: &'a PhysNode, f: &mut impl FnMut(Construct<'a>)) { for t in arrow_types_of(node) { f(Construct::ArrowType(t)); } + if exprs_have_lambda(node) { + f(Construct::Lambda); + } +} + +/// Whether any expression `node` holds is or contains a lambda: the bound +/// body of a higher-order function's argument. +fn exprs_have_lambda(node: &PhysNode) -> bool { + let mut seen = std::collections::HashSet::new(); + let mut stack = expr_roots(node); + while let Some(e) = stack.pop() { + if !seen.insert(Arc::as_ptr(e)) { + continue; + } + match &e.node { + ExprNode::Lambda { .. } | ExprNode::Resolved(ResolvedExpr::LambdaVar(_)) => { + return true; + } + _ => {} + } + e.for_each_child(&mut |c| stack.push(c)); + } + false +} + +/// The expressions `node` holds (its scan filter, project items and the +/// like): [`types_of`] and [`exprs_have_lambda`] walk these. +fn expr_roots(node: &PhysNode) -> Vec<&Arc> { + use krishiv_exec::physical::ProjectItemPlan as Item; + let mut roots: Vec<&Arc> = Vec::new(); + match node { + PhysNode::Scan(scan) => { + roots.extend(scan.filter.iter().map(|f| &f.predicate)); + } + PhysNode::Filter { predicate, .. } => roots.push(predicate), + PhysNode::Project { items: i, .. } => roots.extend(i.iter().filter_map(|p| match p { + Item::Expr { expr, .. } => Some(expr), + Item::Column { .. } | Item::NullOf { .. } => None, + })), + PhysNode::Expand { projections, .. } => { + roots.extend(projections.iter().flat_map(|p| { + p.iter().filter_map(|p| match p { + Item::Expr { expr, .. } => Some(expr), + Item::Column { .. } | Item::NullOf { .. } => None, + }) + })); + } + PhysNode::ReplicateRows { count, .. } => roots.push(count), + PhysNode::HashJoin(j) => roots.extend(j.residual.iter().flat_map(|r| &r.conjuncts)), + PhysNode::NestedLoopJoin(j) => roots.extend(j.residual.iter().flat_map(|r| &r.conjuncts)), + PhysNode::OneRow + | PhysNode::Limit { .. } + | PhysNode::Sort { .. } + | PhysNode::TopN { .. } + | PhysNode::Window { .. } + | PhysNode::WindowGroupLimit { .. } + | PhysNode::Aggregate { .. } + | PhysNode::Union { .. } + | PhysNode::WriteFiles { .. } + | PhysNode::Exchange(_) => {} + } + roots } /// The Arrow types `node` carries as IPC bytes. @@ -371,38 +440,11 @@ fn arrow_types_of(node: &PhysNode) -> Vec<&arrow_schema::DataType> { /// The Spark types `node` holds: those of its scan columns and of every /// expression in it (columns, casts, functions, aliases, typed NULLs). fn types_of<'a>(node: &'a PhysNode) -> Vec<&'a DataType> { - fn items(items: &[ProjectItemPlan]) -> impl Iterator> { - items.iter().filter_map(|i| match i { - ProjectItemPlan::Expr { expr, .. } => Some(expr), - ProjectItemPlan::Column { .. } | ProjectItemPlan::NullOf { .. } => None, - }) - } - let mut roots: Vec<&'a Arc> = Vec::new(); let mut out: Vec<&'a DataType> = Vec::new(); - match node { - PhysNode::Scan(scan) => { - out.extend(scan.scan.output.iter().map(|c| &c.data_type)); - roots.extend(scan.filter.iter().map(|f| &f.predicate)); - } - PhysNode::Filter { predicate, .. } => roots.push(predicate), - PhysNode::Project { items: i, .. } => roots.extend(items(i)), - PhysNode::Expand { projections, .. } => { - roots.extend(projections.iter().flat_map(|p| items(p))); - } - PhysNode::ReplicateRows { count, .. } => roots.push(count), - PhysNode::HashJoin(j) => roots.extend(j.residual.iter().flat_map(|r| &r.conjuncts)), - PhysNode::NestedLoopJoin(j) => roots.extend(j.residual.iter().flat_map(|r| &r.conjuncts)), - PhysNode::OneRow - | PhysNode::Limit { .. } - | PhysNode::Sort { .. } - | PhysNode::TopN { .. } - | PhysNode::Window { .. } - | PhysNode::WindowGroupLimit { .. } - | PhysNode::Aggregate { .. } - | PhysNode::Union { .. } - | PhysNode::WriteFiles { .. } - | PhysNode::Exchange(_) => {} + if let PhysNode::Scan(scan) = node { + out.extend(scan.scan.output.iter().map(|c| &c.data_type)); } + let roots: Vec<&'a Arc> = expr_roots(node); // Expressions share subtrees: each is visited once. let mut seen = std::collections::HashSet::new(); let mut stack = roots; @@ -413,7 +455,9 @@ fn types_of<'a>(node: &'a PhysNode) -> Vec<&'a DataType> { match &e.node { ExprNode::Cast { to, .. } => out.push(to), ExprNode::Literal(Literal::Null(Some(t))) => out.push(t), - ExprNode::Resolved(ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c)) => { + ExprNode::Resolved( + ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c) | ResolvedExpr::LambdaVar(c), + ) => { out.push(&c.data_type); } ExprNode::Resolved(ResolvedExpr::Function(f)) => out.push(&f.data_type), diff --git a/crates/krishiv-plan-codec/src/proto/krishiv.plan.v1.pb.rs b/crates/krishiv-plan-codec/src/proto/krishiv.plan.v1.pb.rs index 915b38332..f10089eb8 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 @@ -695,7 +695,7 @@ pub struct BoundColumn { pub struct Expr { #[prost(message, optional, tag = "1")] pub origin: ::core::option::Option, - #[prost(oneof = "expr::Kind", tags = "2, 3, 4, 5, 6, 7")] + #[prost(oneof = "expr::Kind", tags = "2, 3, 4, 5, 6, 7, 8, 9")] pub kind: ::core::option::Option, } /// Nested message and enum types in `Expr`. @@ -714,8 +714,24 @@ pub mod expr { Cast(super::Cast), #[prost(message, tag = "7")] Alias(super::AliasExpr), + /// feature: lambda_functions + #[prost(message, tag = "8")] + Lambda(super::Lambda), + /// feature: lambda_functions + #[prost(message, tag = "9")] + LambdaVar(super::BoundColumn), } } +/// A lambda (`x -> body`): the bound body of a higher-order function's +/// argument, with its variables as `lambda_var` leaves. +/// feature: lambda_functions +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Lambda { + #[prost(string, repeated, tag = "1")] + pub params: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(uint32, tag = "2")] + pub body: u32, +} #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct AliasExpr { #[prost(uint32, tag = "1")] diff --git a/crates/krishiv-plan-codec/tests/common/inventory.rs b/crates/krishiv-plan-codec/tests/common/inventory.rs index f2b0b2cd7..ce9fefb23 100644 --- a/crates/krishiv-plan-codec/tests/common/inventory.rs +++ b/crates/krishiv-plan-codec/tests/common/inventory.rs @@ -844,6 +844,59 @@ pub(crate) fn expressions() -> PhysNode { } } +/// Lambda expressions and variables: a `transform` over an array column +/// (`transform(xs, x -> x * 2)`). The array type needs `nested_types` too. +pub(crate) fn lambda_functions() -> PhysNode { + let t = |s: &str| parse_data_type(s).unwrap(); + let array = t("array"); + let mut scan = scan(); + if let PhysNode::Scan(s) = &mut scan { + s.scan.output.push(column(3, "xs", array.clone(), true)); + } + let xs = col(3, "xs", array.clone()); + let var = || { + Arc::new(Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar( + column(11, "x", DataType::Integer, true), + )))) + }; + let doubled = call( + Builtin::Multiply, + vec![var(), lit(Literal::Integer(2))], + DataType::Integer, + ); + let transform = Arc::new(Expr::new(ExprNode::Resolved(ResolvedExpr::Function( + ResolvedFunction { + // The codec passes ids through; this is not the registry's. + id: FunctionId::Registry { + name: "transform".to_owned(), + id: 0, + }, + kind: FunctionKind::Scalar, + args: vec![ + xs, + Arc::new(Expr::new(ExprNode::Lambda { + params: vec!["x".to_owned()], + body: doubled, + })), + ], + distinct: false, + filter: None, + data_type: array, + nullable: true, + deterministic: true, + }, + )))); + PhysNode::Project { + input: boxed(scan), + layout: vec![AttrId(1), AttrId(2), AttrId(3)], + items: vec![ProjectItemPlan::Expr { + name: "doubled".to_owned(), + expr: transform, + }], + nullable: None, + subqueries: Vec::new(), + } +} /// Array, map and struct types (depth 4, nullability, a comment) in a /// scan column, a cast, a typed NULL, a function and an alias. pub(crate) fn nested_types() -> PhysNode { @@ -898,5 +951,6 @@ 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(("lambda_functions".to_owned(), plan_of(lambda_functions()))); out } diff --git a/crates/krishiv-plan-codec/tests/features.rs b/crates/krishiv-plan-codec/tests/features.rs index c3fcb3c95..2ee82015a 100644 --- a/crates/krishiv-plan-codec/tests/features.rs +++ b/crates/krishiv-plan-codec/tests/features.rs @@ -34,6 +34,11 @@ fn the_header_lists_exactly_the_features_in_use() { assert_eq!(m.epoch, EPOCH); assert_eq!(message("limit_offset").features, ["limit_offset"]); assert!(message("limit").features.is_empty()); + // A lambda over arrays needs both features. + assert_eq!( + message("lambda_functions").features, + ["lambda_functions", "nested_types"] + ); assert_eq!( message("window_frames").features, ["window", "window_frame_offsets"] @@ -90,6 +95,11 @@ fn constructs_map_to_one_feature_or_the_baseline() { feature_of(Construct::Node(window.root())), Some(Feature::Window) ); + assert_eq!( + feature_of(Construct::Lambda), + Some(Feature::LambdaFunctions) + ); + assert_eq!(Feature::LambdaFunctions.kind(), FeatureKind::Semantic); assert_eq!(feature_of(Construct::Node(&PhysNode::OneRow)), None); let null_of = krishiv_exec::physical::ProjectItemPlan::NullOf { index: 0, @@ -202,6 +212,24 @@ fn a_reader_without_a_feature_refuses_the_plan_naming_it() { } ); assert_eq!(ReaderFeatures::default(), ReaderFeatures::all()); + // A reader without `lambda_functions` refuses the lambda plan naming + // the feature, even though it knows `nested_types`. + let bytes = encode( + &cases() + .into_iter() + .find(|(n, _)| n == "lambda_functions") + .unwrap() + .1, + ) + .unwrap(); + let reader = ReaderFeatures::only([Feature::NestedTypes]); + let err = decode_with(&bytes, &Limits::default(), &reader).unwrap_err(); + assert_eq!( + err, + CodecError::UnsupportedFeatures { + missing: vec!["lambda_functions".to_owned()] + } + ); } #[test] diff --git a/crates/krishiv-plan-codec/tests/golden/lambda_functions/lambda_functions.bin b/crates/krishiv-plan-codec/tests/golden/lambda_functions/lambda_functions.bin new file mode 100644 index 0000000000000000000000000000000000000000..dd7dd44d8d367e88f1661276ca7fb0849b18a1fc GIT binary patch literal 1100 zcmb_bPixdb6rY(So7vf2n@+37;34EBpJ#4OKbGD<{Ui)FHv$WqRvGW)HzP)1H= z4f=7Vj3|_TJ}=8;Wa_zm7vp$8br=>YV^}kLY|GT!h?9 zjt~ZE6DR;4pj&7SY}P9P9sGCsUK1NzbsOH~Fd*#o>4m@E=+VW~=uWc9 z9ZZ~PzIWaT%j)ykH({!op@&DXLHw9$cU4{5k% z_Bpnd&)4I8o5LRa1bX>=8)fs_m>j4b0s3nMZEY0Vk=Wxlw~f;v-*j{Watyo7-IEi; zaoPTg3CD{eV_sHFPfUdIaD%y7RT&PD1PGLXB19fJJ6yykfRFfG=(w1ws+Rd~NO7?G z?u73@u6}>}`lXZjLWy#zO*XiO$1F-i)-ANEi~>M~IKgN{DA~r(aOQIIU^ClD*BO2S z7N~Y*x}9z?N2uJY9eky>5pFiv?a>}I4=4x7w+T|~+3~>BYjXQL9>a^k&-VW39%Qf6 xR{*uHsfE&$s-D@ZT{^n)irJnIf>O+mb8$GCtFb96r4RZ_Y9sSQySw@b{{f5N!T|sP literal 0 HcmV?d00001 diff --git a/crates/krishiv-plan-codec/tests/roundtrip.rs b/crates/krishiv-plan-codec/tests/roundtrip.rs index 902444870..31bc02414 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" | "lambda_functions" => 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/exprs.rs b/crates/krishiv-plan/src/analyzer/exprs.rs index 3c579b781..b6a5da78f 100644 --- a/crates/krishiv-plan/src/analyzer/exprs.rs +++ b/crates/krishiv-plan/src/analyzer/exprs.rs @@ -567,9 +567,9 @@ fn is_special(value: &str) -> bool { /// `sum(x)` in `sum(x) OVER w` is a window aggregate, not an aggregate of /// the operator). #[derive(Clone, Copy, PartialEq, Eq, Hash)] -struct Ctx { - agg: bool, - window_fn: bool, +pub(super) struct Ctx { + pub(super) agg: bool, + pub(super) window_fn: bool, } enum Step { @@ -583,14 +583,27 @@ impl Resolver<'_> { /// Binds `e` in `cx`, post-order with an explicit stack; a node shared /// within the expression is bound once. pub(super) fn expr(&mut self, e: &Arc, cx: &Cx<'_>) -> Result { - let mut done: HashMap<(usize, Ctx), Bound> = HashMap::new(); - // Rewritten calls stay alive for the pass: `done` is keyed by - // address. - let mut rewritten_calls: Vec> = Vec::new(); let top = Ctx { agg: false, window_fn: false, }; + self.expr_in(top, e, cx) + } + + /// Binds `e` in `cx` under the step context `top` (see [`Self::expr`]). + /// Higher-order calls bind their children through this with each + /// child's own context, so names inside lambdas resolve as the generic + /// path would resolve them. + pub(super) fn expr_in( + &mut self, + top: Ctx, + e: &Arc, + cx: &Cx<'_>, + ) -> Result { + let mut done: HashMap<(usize, Ctx), Bound> = HashMap::new(); + // Rewritten calls stay alive for the pass: `done` is keyed by + // address. + let mut rewritten_calls: Vec> = Vec::new(); let mut stack = vec![Step::Enter(Arc::clone(e), top)]; while let Some(step) = stack.pop() { match step { @@ -604,6 +617,36 @@ impl Resolver<'_> { stack.push(Step::Enter(rewritten, ctx)); continue; } + // A lambda binds where it is used: a higher-order + // call binds its array and lambda children itself + // (see `hof`), while a lambda anywhere else is no + // higher-order call's argument. + if let ExprNode::Function(f) = &x.node + && (super::hof::Hof::of(&f.name).is_some() + || super::hof::has_direct_lambda(f)) + { + let Some(h) = super::hof::Hof::of(&f.name) else { + return Err(super::hof::not_higher_order(&f.name, x.origin)); + }; + let kids = self.child_ctx(&x, ctx); + for (key, bound) in self.hof_children(&x, h, &kids, cx)? { + let step = kids + .iter() + .find(|(c, _)| addr(&**c) == key) + .map(|(_, k)| *k) + .unwrap_or(ctx); + done.insert((key, step), bound); + } + stack.push(Step::Exit(Arc::clone(&x), ctx)); + let lambda = addr(&*f.args[1]); + stack.extend( + kids.into_iter() + .rev() + .filter(|(c, _)| addr(&**c) != lambda) + .map(|(c, k)| Step::Enter(c, k)), + ); + continue; + } stack.push(Step::Exit(Arc::clone(&x), ctx)); let kids = self.child_ctx(&x, ctx); stack.extend(kids.into_iter().rev().map(|(c, k)| Step::Enter(c, k))); @@ -947,6 +990,15 @@ impl Resolver<'_> { e.origin, )); } + // A lambda outside a higher-order function's argument list: + // lambdas in argument position are bound by the higher-order + // call itself (see `hof`), never here. + ExprNode::Lambda { .. } => { + return Err(unsupported( + "lambda functions outside a higher-order function", + e.origin, + )); + } ExprNode::Function(f) => { let n = f.args.len(); if let Some(filter) = kids.get(n) @@ -1129,7 +1181,9 @@ impl Resolver<'_> { } ExprNode::Window(w) => self.window(e, w, kids, cx)?, ExprNode::Resolved(r) => keep(match r { - ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c) => column(c), + ResolvedExpr::Column(c) + | ResolvedExpr::OuterColumn(c) + | ResolvedExpr::LambdaVar(c) => column(c), ResolvedExpr::Alias { output, .. } => column(output), ResolvedExpr::Function(f) => arg_type(f.data_type.clone(), f.nullable), }), @@ -1913,6 +1967,19 @@ impl Resolver<'_> { col.name.clone_from(&parts[used - 1]); col }; + if c.plan_id.is_none() + && let [name] = &c.name[..] + && let Some(var) = self.lambda_var(name) + { + // A lambda variable shadows the enclosing query's columns. + let mut col = var; + col.name.clone_from(name); + return Ok(bound( + ExprNode::Resolved(ResolvedExpr::LambdaVar(col.clone())), + &col, + None, + )); + } if let Some(id) = c.plan_id { let a = self.plan_column(id, &c.name, cx, origin)?; self.used(&a); @@ -2439,6 +2506,14 @@ fn pretty_node(x: &Expr, k: &[&str], zone: Option) -> String { } } ExprNode::Star(_) => "*".to_owned(), + // Spark's `lambdafunction(body, arg1, ...)`: the variables render + // as `namedlambdavariable()` when hidden (see `hof`). + ExprNode::Lambda { params, .. } => { + let mut args = vec![k[0].to_owned()]; + args.extend(params.iter().cloned()); + format!("lambdafunction({})", args.join(", ")) + } + ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => c.name.clone(), ExprNode::Window(w) => pretty_window(w, k, zone), ExprNode::Function(FunctionCall { name, distinct, .. }) => { call(name, Builtin::from_name(name), *distinct, k, None) diff --git a/crates/krishiv-plan/src/analyzer/hof.rs b/crates/krishiv-plan/src/analyzer/hof.rs new file mode 100644 index 000000000..fbe13d482 --- /dev/null +++ b/crates/krishiv-plan/src/analyzer/hof.rs @@ -0,0 +1,316 @@ +// SPDX-License-Identifier: Apache-2.0 +//! Higher-order functions over arrays: `transform`, `filter`, `exists` and +//! `forall` (Spark's `ArrayHigherOrderFunction`s with lambda bodies). +//! +//! A lambda (`x -> body`) is bound where it is used: the higher-order call +//! binds its array argument first, pushes the lambda variables (typed with +//! the array's element type) for the body, then pops them (Spark's +//! `NamedLambdaVariable`). The variables shadow the enclosing query's +//! columns, innermost lambda first, case-sensitively per the session. +//! +//! An argument that is not a lambda is a constant lambda: the body is the +//! argument itself over hidden variables, as Spark analyzes +//! `transform(arr, 42)` to `[42, 42, 42]` and rejects `filter(arr, 1)` with +//! `DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE` quoting +//! `lambdafunction(1, namedlambdavariable())`. The wrapped node carries the +//! hidden variables so names and errors render as Spark's. +//! +//! The call itself is typed by the generic path once its children are +//! bound: the lambda child's type is its body's, and the registry's result +//! rules (see `krishiv-functions`) check the array and body types. + +use std::sync::Arc; + +use krishiv_common::error::{ + InvalidLambdaFunctionCallDuplicateArgNames, InvalidLambdaFunctionCallNonHigherOrderFunction, + InvalidLambdaFunctionCallNumArgsMismatch, WrongNumArgsWithoutSuggestion, +}; +use krishiv_types::{ArrayType, DataType}; + +use super::AnalysisError; +use super::bind::{addr, same, unsupported}; +use super::catalog::ArgType; +use super::exprs::{Bound, Ctx, Cx, SPARK_DOC_ROOT}; +use super::resolve::Resolver; +use crate::{BoundColumn, Expr, ExprNode, FunctionCall, Origin}; + +/// One pushed lambda scope: its variables, innermost last. +#[derive(Debug, Clone, Default)] +pub(super) struct LambdaFrame { + /// The variables, in parameter order. + pub(super) vars: Vec, +} + +/// A higher-order function over arrays. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(super) enum Hof { + /// `transform(arr, x -> ...)` or `transform(arr, (x, i) -> ...)`. + Transform, + /// `filter(arr, x -> ...)`. + Filter, + /// `exists(arr, x -> ...)`. + Exists, + /// `forall(arr, x -> ...)`. + ForAll, +} + +impl Hof { + /// The higher-order function `name` calls, if one (ASCII + /// case-insensitive, as function names are). + #[must_use] + pub(super) fn of(name: &str) -> Option { + Some(match name.to_ascii_lowercase().as_str() { + "transform" => Self::Transform, + "filter" => Self::Filter, + "exists" => Self::Exists, + "forall" => Self::ForAll, + _ => return None, + }) + } + + /// The name, lower case (as the registry lists it). + const fn name(self) -> &'static str { + match self { + Self::Transform => "transform", + Self::Filter => "filter", + Self::Exists => "exists", + Self::ForAll => "forall", + } + } + + /// The argument holding the array. + const fn array(self) -> usize { + 0 + } + + /// The argument holding the lambda. + const fn lambda(self) -> usize { + 1 + } + + /// The lambda's parameter counts `(min, max)`. + const fn params(self) -> (usize, usize) { + match self { + // The index is the optional second variable. + Self::Transform => (1, 2), + Self::Filter | Self::Exists | Self::ForAll => (1, 1), + } + } + + /// The display of `expectedNumArgs` for a lambda of the wrong shape. + const fn expected_params(self) -> &'static str { + match self { + Self::Transform => "1 to 2", + Self::Filter | Self::Exists | Self::ForAll => "1", + } + } +} + +/// Whether `f` takes a lambda as a direct argument: only a higher-order +/// call may. +pub(super) fn has_direct_lambda(f: &FunctionCall) -> bool { + f.args + .iter() + .any(|a| matches!(a.node, ExprNode::Lambda { .. })) +} + +/// The error for a lambda in `name`'s argument list when `name` is no +/// higher-order function (Spark's `INVALID_LAMBDA_FUNCTION_CALL` names the +/// enclosing expression's class). +pub(super) fn not_higher_order(name: &str, origin: Origin) -> AnalysisError { + AnalysisError::new( + InvalidLambdaFunctionCallNonHigherOrderFunction { + class: catalyst_class(name), + }, + origin, + ) +} + +/// The Catalyst class Spark's message names for a function called with a +/// lambda. Pinned by the goldens for `upper` and `ceil`; anything else is +/// the usual class shape (`Upper` for `upper`), which is best-effort. +fn catalyst_class(name: &str) -> String { + if name.eq_ignore_ascii_case("ceil") || name.eq_ignore_ascii_case("ceiling") { + return "org.apache.spark.sql.catalyst.expressions.CeilExpressionBuilder$".to_owned(); + } + let mut class = name.to_ascii_lowercase(); + if let Some(first) = class.get_mut(..1) { + first.make_ascii_uppercase(); + } + format!("org.apache.spark.sql.catalyst.expressions.{class}") +} + +impl Resolver<'_> { + /// The innermost lambda variable `name` names, if any. + pub(super) fn lambda_var(&self, name: &str) -> Option { + let cs = self.ctx.conf.case_sensitive; + self.lambdas + .iter() + .rev() + .flat_map(|f| f.vars.iter().rev()) + .find(|v| same(&v.name, name, cs)) + .cloned() + } + + /// Binds the higher-order call `e`'s array child, then its lambda + /// child: the array first, so the lambda variables take its element + /// type. Returns each child with the address the generic path binds it + /// under; the caller records both and leaves the rest of the call to + /// the generic path. + /// + /// # Errors + /// A lambda error, as Spark reports it. + pub(super) fn hof_children( + &mut self, + e: &Arc, + h: Hof, + kids: &[(Arc, Ctx)], + cx: &Cx<'_>, + ) -> Result<[(usize, Bound); 2], AnalysisError> { + let ExprNode::Function(f) = &e.node else { + return Err(unsupported("a higher-order call", e.origin)); + }; + // Arity first, as Spark checks it: every function here takes the + // array and the lambda. + if f.args.len() != 2 { + return Err(AnalysisError::new( + WrongNumArgsWithoutSuggestion { + function_name: format!("`{}`", h.name()), + expected_num: "2".to_owned(), + actual_num: f.args.len().to_string(), + docroot: SPARK_DOC_ROOT.to_owned(), + }, + e.origin, + )); + } + let at = |i: usize| { + kids.iter() + .find(|(c, _)| addr(&**c) == addr(&*f.args[i])) + .map(|(_, k)| *k) + }; + let array_ctx = at(h.array()).unwrap_or(Ctx { + agg: false, + window_fn: false, + }); + let lambda_ctx = at(h.lambda()).unwrap_or(array_ctx); + let array = self.expr_in(array_ctx, &f.args[h.array()], cx)?; + let lambda = self.hof_lambda(h, lambda_ctx, &array.ty, &f.args[h.lambda()], cx)?; + Ok([ + (addr(&*f.args[h.array()]), array), + (addr(&*f.args[h.lambda()]), lambda), + ]) + } + + /// Binds the lambda `node` against `array_ty`: its variables, then its + /// body. A node that is no lambda is a constant lambda over one hidden + /// variable (see the module doc). + /// + /// # Errors + /// A lambda error, as Spark reports it. + fn hof_lambda( + &mut self, + h: Hof, + step: Ctx, + array_ty: &ArgType, + node: &Arc, + cx: &Cx<'_>, + ) -> Result { + let hidden = !matches!(node.node, ExprNode::Lambda { .. }); + let (params, inner) = match &node.node { + ExprNode::Lambda { params, body } => (params.clone(), Arc::clone(body)), + // A constant lambda: the argument is the body. + _ => (vec!["namedlambdavariable()".to_owned()], Arc::clone(node)), + }; + let (min, max) = h.params(); + if params.len() < min || params.len() > max { + return Err(AnalysisError::new( + InvalidLambdaFunctionCallNumArgsMismatch { + expected_num_args: h.expected_params().to_owned(), + actual_num_args: params.len().to_string(), + }, + node.origin, + )); + } + if !hidden && let Some(dup) = duplicate_param(¶ms, self.ctx.conf.case_sensitive) { + return Err(AnalysisError::new( + InvalidLambdaFunctionCallDuplicateArgNames { + args: format!("[{}]", dup.join(", ")), + case_sensitive_config: format!( + "spark.sql.caseSensitive is set to {}", + self.ctx.conf.case_sensitive + ), + }, + node.origin, + )); + } + // The element type, or `NULL` when the array check fails: the + // result rule reports the array, so the lambda still binds (names + // resolve before types, as in Spark). + let element = match &array_ty.data_type { + Some(DataType::Array(element)) => element.as_ref().clone(), + _ => ArrayType::new(DataType::Null, true), + }; + let mut vars = vec![BoundColumn { + id: self.fresh(), + name: params[0].clone(), + data_type: element.element_type().clone(), + nullable: element.contains_null(), + }]; + if params.len() == 2 { + vars.push(BoundColumn { + id: self.fresh(), + name: params[1].clone(), + data_type: DataType::Integer, + nullable: false, + }); + } + self.lambdas.push(LambdaFrame { vars }); + let body = self.expr_in(step, &inner, cx); + self.lambdas.pop(); + let body = body?; + // An aggregate or window over the lambda's elements is no outer + // query aggregate: a constant lambda's own aggregates stay outer + // aggregates, as the generic path resolves them. + if !hidden && body.agg.is_some() { + return Err(unsupported( + "aggregate functions in lambda functions", + node.origin, + )); + } + if !hidden && body.win.is_some() { + return Err(unsupported( + "window functions in lambda functions", + node.origin, + )); + } + let ty = body.ty.clone(); + Ok(Bound { + expr: Arc::new( + Expr::new(ExprNode::Lambda { + params, + body: Arc::clone(&body.expr), + }) + .with_origin(node.origin), + ), + ty, + agg: hidden.then_some(body.agg).flatten(), + win: hidden.then_some(body.win).flatten(), + outer: body.outer, + lateral: body.lateral, + shown: (!hidden).then(|| Arc::clone(node)), + }) + } +} + +/// The first parameter `params` repeats (case-sensitively per `cs`), if +/// any. +fn duplicate_param(params: &[String], cs: bool) -> Option> { + for (i, a) in params.iter().enumerate() { + for b in ¶ms[..i] { + if same(a, b, cs) { + return Some(vec![a.clone()]); + } + } + } + None +} diff --git a/crates/krishiv-plan/src/analyzer/mod.rs b/crates/krishiv-plan/src/analyzer/mod.rs index 138839d46..1a22216bd 100644 --- a/crates/krishiv-plan/src/analyzer/mod.rs +++ b/crates/krishiv-plan/src/analyzer/mod.rs @@ -71,6 +71,7 @@ mod exprs; mod fold; mod fold_ops; mod hints; +mod hof; mod ops; mod pivot; mod resolve; diff --git a/crates/krishiv-plan/src/analyzer/resolve.rs b/crates/krishiv-plan/src/analyzer/resolve.rs index 66a9d64b5..6ea527094 100644 --- a/crates/krishiv-plan/src/analyzer/resolve.rs +++ b/crates/krishiv-plan/src/analyzer/resolve.rs @@ -130,6 +130,9 @@ pub(super) struct Resolver<'a> { /// input shares subtrees, so equal input keys give equal plans. canon: HashMap>, pub(super) columns: Vec>, + /// The lambda scopes pushed by the higher-order calls whose bodies + /// bind now, innermost last (see `hof`). + pub(super) lambdas: Vec, depth: usize, op_outer: Option, root_env: Option>, @@ -162,6 +165,7 @@ pub(super) fn resolve( op_outer: None, root_env: None, folds: std::cell::RefCell::default(), + lambdas: Vec::new(), }; // Fresh ids start past every id the input already holds (a plan that // is resolved in part, or re-analysed). diff --git a/crates/krishiv-plan/src/display.rs b/crates/krishiv-plan/src/display.rs index bcf6b36b2..ff9b85492 100644 --- a/crates/krishiv-plan/src/display.rs +++ b/crates/krishiv-plan/src/display.rs @@ -650,12 +650,16 @@ fn expr_pieces<'a>(e: &'a Expr, out: &mut Vec>) { out.push(Piece::Str(") IN (list-query))")); } }, - ExprNode::Resolved(ResolvedExpr::Column(c)) => { + ExprNode::Resolved(ResolvedExpr::Column(c) | ResolvedExpr::LambdaVar(c)) => { out.push(Piece::Owned(format!("{}#{}", c.name, c.id.0))); } ExprNode::Resolved(ResolvedExpr::OuterColumn(c)) => { out.push(Piece::Owned(format!("outer({}#{})", c.name, c.id.0))); } + ExprNode::Lambda { params, body } => { + out.push(Piece::Owned(format!("({}) -> ", params.join(", ")))); + out.push(Piece::Expr(body)); + } ExprNode::Resolved(ResolvedExpr::Alias { expr, output }) => { out.push(Piece::Expr(expr)); out.push(Piece::Owned(format!(" AS {}#{}", output.name, output.id.0))); diff --git a/crates/krishiv-plan/src/encode.rs b/crates/krishiv-plan/src/encode.rs index 9ba7eb374..9a3940524 100644 --- a/crates/krishiv-plan/src/encode.rs +++ b/crates/krishiv-plan/src/encode.rs @@ -1054,6 +1054,15 @@ impl<'k, 'a> Encoder<'k, 'a> { self.bound(output); self.expr(expr); } + ExprNode::Lambda { params, body } => { + self.u8(13); + self.strs(params); + self.expr(body); + } + ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => { + self.u8(14); + self.bound(c); + } ExprNode::Window(crate::WindowExpr { function, window }) => { self.u8(12); self.expr(function); diff --git a/crates/krishiv-plan/src/expr.rs b/crates/krishiv-plan/src/expr.rs index 09f543900..469e9fbe5 100644 --- a/crates/krishiv-plan/src/expr.rs +++ b/crates/krishiv-plan/src/expr.rs @@ -67,6 +67,19 @@ pub enum ExprNode { Star(Star), /// An unresolved function call, operators included. Function(FunctionCall), + /// `x -> body` or `(x, y) -> body`: a lambda, bound by the analyzer + /// only as a direct argument of a higher-order function (`transform`, + /// `filter`, `exists`, `forall`, ...), where its variables take the + /// argument's element types (Spark's `NamedLambdaVariable`). The node + /// stays in place when bound: its body then holds + /// [`ResolvedExpr::LambdaVar`] leaves. + Lambda { + /// The variable names, as written. + params: Vec, + /// The body, resolved against the variables and the enclosing + /// query's columns. + body: Arc, + }, /// `CAST(expr AS to)`; `TRY_CAST` is [`CastMode::Try`]. Cast { /// The value to cast. @@ -372,6 +385,11 @@ pub enum ResolvedExpr { Column(BoundColumn), /// A column of an enclosing query, inside a correlated subquery. OuterColumn(BoundColumn), + /// A lambda variable, bound by the analyzer to one of the enclosing + /// [`ExprNode::Lambda`] node's parameters (Spark's + /// `NamedLambdaVariable`). It is not an output attribute: only the + /// higher-order function compiled around the lambda reads it. + LambdaVar(BoundColumn), /// A function bound to its identity and result type. Function(ResolvedFunction), /// `expr AS name`, producing a new attribute. @@ -426,6 +444,15 @@ impl Expr { })) } + /// An unresolved `params -> body` lambda. + #[must_use] + pub fn lambda(params: Vec, body: Self) -> Self { + Self::new(ExprNode::Lambda { + params, + body: Arc::new(body), + }) + } + /// An unresolved call of a canonical operator. #[must_use] pub fn builtin(op: Builtin, args: Vec) -> Self { @@ -475,7 +502,9 @@ impl Expr { | ExprNode::Literal(_) | ExprNode::TypedLiteral { .. } | ExprNode::Star(_) - | ExprNode::Resolved(ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_)) => {} + | ExprNode::Resolved( + ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_) | ResolvedExpr::LambdaVar(_), + ) => {} ExprNode::Function(FunctionCall { args, filter, .. }) | ExprNode::Resolved(ResolvedExpr::Function(ResolvedFunction { args, filter, .. @@ -485,6 +514,7 @@ impl Expr { } ExprNode::Cast { expr, .. } | ExprNode::Alias { expr, .. } + | ExprNode::Lambda { body: expr, .. } | ExprNode::Resolved(ResolvedExpr::Alias { expr, .. }) => f(expr), ExprNode::Subquery { kind, .. } => match kind { SubqueryKind::In(values) => values.iter().for_each(f), @@ -515,7 +545,9 @@ impl Expr { | ExprNode::Literal(_) | ExprNode::TypedLiteral { .. } | ExprNode::Star(_) - | ExprNode::Resolved(ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_)) => {} + | ExprNode::Resolved( + ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_) | ResolvedExpr::LambdaVar(_), + ) => {} ExprNode::Function(FunctionCall { args, filter, .. }) | ExprNode::Resolved(ResolvedExpr::Function(ResolvedFunction { args, filter, .. @@ -525,6 +557,7 @@ impl Expr { } ExprNode::Cast { expr, .. } | ExprNode::Alias { expr, .. } + | ExprNode::Lambda { body: expr, .. } | ExprNode::Resolved(ResolvedExpr::Alias { expr, .. }) => f(expr), ExprNode::Subquery { kind, .. } => match kind { SubqueryKind::In(values) => values.iter_mut().for_each(f), diff --git a/crates/krishiv-plan/src/tests/inventory.rs b/crates/krishiv-plan/src/tests/inventory.rs index 077db3f6c..d8526fd76 100644 --- a/crates/krishiv-plan/src/tests/inventory.rs +++ b/crates/krishiv-plan/src/tests/inventory.rs @@ -63,8 +63,10 @@ fn expr_kinds(expr: &Expr, out: &mut BTreeSet<&'static str>) { ExprNode::Alias { .. } => "ExprNode::Alias", ExprNode::Subquery { .. } => "ExprNode::Subquery", ExprNode::Window(_) => "ExprNode::Window", + ExprNode::Lambda { .. } => "ExprNode::Lambda", ExprNode::Resolved(ResolvedExpr::Column(_)) => "ResolvedExpr::Column", ExprNode::Resolved(ResolvedExpr::OuterColumn(_)) => "ResolvedExpr::OuterColumn", + ExprNode::Resolved(ResolvedExpr::LambdaVar(_)) => "ResolvedExpr::LambdaVar", ExprNode::Resolved(ResolvedExpr::Function(_)) => "ResolvedExpr::Function", ExprNode::Resolved(ResolvedExpr::Alias { .. }) => "ResolvedExpr::Alias", }); diff --git a/crates/krishiv-plan/src/tests/props.rs b/crates/krishiv-plan/src/tests/props.rs index af7d8ce76..12cfcf2fd 100644 --- a/crates/krishiv-plan/src/tests/props.rs +++ b/crates/krishiv-plan/src/tests/props.rs @@ -721,6 +721,10 @@ fn m_expr(e: &mut Arc, w: &mut Walk) -> bool { m_type(to, w) || m_expr(expr, w) } ExprNode::Alias { expr, name } => m_string(name, w) || m_expr(expr, w), + ExprNode::Lambda { params, body } => { + site!(w, params.push("x".to_owned())); + m_expr(body, w) + } ExprNode::Subquery { kind, plan } => { let other = match kind { SubqueryKind::Scalar => SubqueryKind::Exists, @@ -750,7 +754,9 @@ fn m_expr(e: &mut Arc, w: &mut Walk) -> bool { inside || m_expr(function, w) } ExprNode::Resolved(r) => match r { - ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c) => m_bound(c, w), + ResolvedExpr::Column(c) | ResolvedExpr::OuterColumn(c) | ResolvedExpr::LambdaVar(c) => { + m_bound(c, w) + } ResolvedExpr::Function(ResolvedFunction { id, kind, diff --git a/crates/krishiv-plan/src/walk.rs b/crates/krishiv-plan/src/walk.rs index 2b7b31b0d..3142545e7 100644 --- a/crates/krishiv-plan/src/walk.rs +++ b/crates/krishiv-plan/src/walk.rs @@ -179,7 +179,12 @@ pub(crate) fn all_resolved(root: Node<'_>) -> bool { &w.window, crate::WindowSpecRef::Spec(crate::WindowSpec { frame: Some(_), .. }) ), - ExprNode::Literal(_) | ExprNode::Subquery { .. } | ExprNode::Resolved(_) => true, + // A lambda is resolved once its body is (visited on its + // own); its parameters are plain names. + ExprNode::Lambda { .. } + | ExprNode::Literal(_) + | ExprNode::Subquery { .. } + | ExprNode::Resolved(_) => true, }, }; if resolved { @@ -371,7 +376,9 @@ impl Teardown { | ExprNode::Literal(_) | ExprNode::TypedLiteral { .. } | ExprNode::Star(_) - | ExprNode::Resolved(ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_)) => {} + | ExprNode::Resolved( + ResolvedExpr::Column(_) | ResolvedExpr::OuterColumn(_) | ResolvedExpr::LambdaVar(_), + ) => {} ExprNode::Function(FunctionCall { args, filter, .. }) | ExprNode::Resolved(ResolvedExpr::Function(ResolvedFunction { args, filter, .. @@ -381,6 +388,7 @@ impl Teardown { } ExprNode::Cast { expr, .. } | ExprNode::Alias { expr, .. } + | ExprNode::Lambda { body: expr, .. } | ExprNode::Resolved(ResolvedExpr::Alias { expr, .. }) => self.exprs.push(expr), ExprNode::Subquery { kind, plan } => { self.plans.push(plan); diff --git a/crates/krishiv-session/tests/datetime_calendar.rs b/crates/krishiv-session/tests/datetime_calendar.rs index d9ab61632..f67998dc8 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), @@ -311,7 +311,6 @@ fn expected_not_run() -> BTreeMap { ("unsupported: INTERVAL literals".to_owned(), 144), ("unsupported: TIME literals".to_owned(), 6), ("unsupported: function DATE".to_owned(), 4), - ("unsupported: function array".to_owned(), 74), ("unsupported: function map".to_owned(), 74), ("unsupported: function named_struct".to_owned(), 74), ( diff --git a/crates/krishiv-session/tests/higher_order.rs b/crates/krishiv-session/tests/higher_order.rs new file mode 100644 index 000000000..9336f16d3 --- /dev/null +++ b/crates/krishiv-session/tests/higher_order.rs @@ -0,0 +1,375 @@ +// SPDX-License-Identifier: Apache-2.0 +//! Higher-order functions over arrays end to end: `transform`, `filter`, +//! `exists` and `forall`, with the `array` constructor they need. Values, +//! output names and error classes follow Spark 4.2's +//! `higher-order-functions.sql` golden; the error texts of the +//! constant-lambda mismatches match its `messageParameters` exactly. +#![cfg(test)] + +use std::sync::Arc; + +use arrow_array::cast::AsArray; +use arrow_array::{Array, ArrayRef, Int32Array, ListArray, RecordBatch}; +use arrow_buffer::{NullBuffer, OffsetBuffer, ScalarBuffer}; +use arrow_schema::{DataType as ArrowType, Field, Schema}; +use futures::executor::block_on; +use krishiv_common::error::{ErrorClass, KrishivError}; +use krishiv_session::Session; +use krishiv_types::{ArrayType, DataType}; + +/// `t(ys array, zs array>, n int)`, five rows: two +/// populated, `[12]`, a NULL row and an empty row. +fn session() -> Session { + let s = Session::new().unwrap(); + let element = Field::new("element", ArrowType::Int32, false); + let mut ys_builder = + arrow_array::builder::ListBuilder::new(arrow_array::builder::Int32Builder::new()) + .with_field(Arc::new(element.clone())); + ys_builder.append_value([Some(32), Some(97)]); + ys_builder.append_value([Some(77), Some(-76)]); + ys_builder.append_value([Some(12)]); + ys_builder.append_null(); + ys_builder.append_value([]); + let ys: ArrayRef = Arc::new(ys_builder.finish()); + let inner: ArrayRef = Arc::new(ListArray::new( + Arc::new(element), + OffsetBuffer::new(ScalarBuffer::from(vec![0, 2, 3, 3, 4])), + Arc::new(Int32Array::from(vec![1, 2, 3, 4])), + None, + )); + let zs = ListArray::new( + Arc::new(Field::new( + "element", + ArrowType::List(Arc::new(Field::new("element", ArrowType::Int32, false))), + true, + )), + OffsetBuffer::new(ScalarBuffer::from(vec![0, 2, 2, 3, 3, 4])), + inner, + Some(NullBuffer::from(vec![true, false, true, false, true])), + ); + let n: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); + let schema = Arc::new(Schema::new(vec![ + Field::new("ys", ys.data_type().clone(), true), + Field::new("zs", zs.data_type().clone(), true), + Field::new("n", ArrowType::Int32, false), + ])); + let batch = RecordBatch::try_new(Arc::clone(&schema), vec![ys, Arc::new(zs), n]).unwrap(); + s.register_batches("t", schema, vec![batch]).unwrap(); + s +} + +/// `SELECT CAST( AS STRING) []`: every row of the single +/// column, `None` for NULL. +fn strings(s: &Session, expr: &str, from: &str) -> Vec> { + let sql = format!("SELECT CAST({expr} AS STRING) {from}"); + let df = block_on(s.sql(&sql)).unwrap_or_else(|e| panic!("{sql}: {e}")); + block_on(df.collect()) + .unwrap_or_else(|e| panic!("{sql}: {e}")) + .iter() + .flat_map(|b| { + b.column(0) + .as_string_view() + .iter() + .map(|v| v.map(str::to_owned)) + .collect::>() + }) + .collect() +} + +fn error(s: &Session, sql: &str) -> KrishivError { + match block_on(s.sql(sql)) { + Ok(_) => panic!("{sql} resolved"), + Err(e) => e, + } +} + +#[test] +fn transform_maps_each_element() { + let s = session(); + assert_eq!( + strings(&s, "transform(ys, y -> y * y)", "FROM t"), + [ + Some("[1024, 9409]".to_owned()), + Some("[5929, 5776]".to_owned()), + Some("[144]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); + // A NULL array is NULL, whatever the body. + assert_eq!( + strings(&s, "transform(CAST(NULL AS ARRAY), x -> x + 1)", ""), + [None] + ); + // A constant lambda repeats its body. + assert_eq!( + strings(&s, "transform(array(1, 2, 3), 42)", ""), + [Some("[42, 42, 42]".to_owned())] + ); +} + +#[test] +fn transform_with_index_and_captures() { + let s = session(); + // The index counts positions within each list. + assert_eq!( + strings(&s, "transform(ys, (y, i) -> y + i)", "FROM t"), + [ + Some("[32, 98]".to_owned()), + Some("[77, -75]".to_owned()), + Some("[12]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); + // An outer column repeats per element. + assert_eq!( + strings(&s, "transform(ys, y -> y + n)", "FROM t"), + [ + Some("[33, 98]".to_owned()), + Some("[79, -74]".to_owned()), + Some("[15]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); + // A lambda variable shadows an outer column of the same name. + assert_eq!( + strings(&s, "transform(ys, n -> n + 1)", "FROM t"), + [ + Some("[33, 98]".to_owned()), + Some("[78, -75]".to_owned()), + Some("[13]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); +} + +#[test] +fn higher_order_functions_nest() { + let s = session(); + assert_eq!( + strings(&s, "transform(zs, z -> filter(z, zz -> zz > 1))", "FROM t"), + [ + Some("[[2], [3]]".to_owned()), + None, + Some("[[]]".to_owned()), + None, + Some("[[4]]".to_owned()), + ] + ); +} + +#[test] +fn filter_keeps_true_elements() { + let s = session(); + assert_eq!( + strings(&s, "filter(ys, y -> y > 30)", "FROM t"), + [ + Some("[32, 97]".to_owned()), + Some("[77]".to_owned()), + Some("[]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); + // A NULL predicate drops its element; a NULL array is NULL. + assert_eq!( + strings(&s, "filter(array(1, NULL, 3), x -> x > 1)", ""), + [Some("[3]".to_owned())] + ); + assert_eq!( + strings(&s, "filter(CAST(NULL AS ARRAY), y -> TRUE)", ""), + [None] + ); + assert_eq!( + strings(&s, "filter(array(1, 2, 3), TRUE)", ""), + [Some("[1, 2, 3]".to_owned())] + ); +} + +#[test] +fn exists_and_forall_fold_the_marks() { + let s = session(); + assert_eq!( + strings(&s, "exists(ys, y -> y > 30)", "FROM t"), + [ + Some("true".to_owned()), + Some("true".to_owned()), + Some("false".to_owned()), + None, + Some("false".to_owned()), + ] + ); + assert_eq!( + strings(&s, "forall(ys, y -> y > 30)", "FROM t"), + [ + Some("true".to_owned()), + Some("false".to_owned()), + Some("false".to_owned()), + None, + Some("true".to_owned()), + ] + ); + // A NULL array folds to NULL, whatever the body. + assert_eq!( + strings(&s, "exists(CAST(NULL AS ARRAY), y -> y > 30)", ""), + [None] + ); + assert_eq!( + strings(&s, "forall(CAST(NULL AS ARRAY), y -> y > 30)", ""), + [None] + ); + // NULL marks decide nothing: no true for `exists`, no false for + // `forall` (Spark's source shape, unverified against a run). + assert_eq!( + strings(&s, "exists(array(1, NULL), x -> x > 1)", ""), + [Some("false".to_owned())] + ); + assert_eq!( + strings(&s, "forall(array(1, NULL), x -> x >= 1)", ""), + [Some("true".to_owned())] + ); +} + +#[test] +fn array_builds_lists() { + let s = session(); + assert_eq!( + strings(&s, "array(1, 2, 3)", ""), + [Some("[1, 2, 3]".to_owned())] + ); + assert_eq!(strings(&s, "array()", ""), [Some("[]".to_owned())]); + assert_eq!( + strings(&s, "array(NULL, NULL)", ""), + [Some("[null, null]".to_owned())] + ); + // Over columns, with the common type. + assert_eq!( + strings(&s, "array(n, n * 2)", "FROM t"), + [ + Some("[1, 2]".to_owned()), + Some("[2, 4]".to_owned()), + Some("[3, 6]".to_owned()), + Some("[4, 8]".to_owned()), + Some("[5, 10]".to_owned()), + ] + ); +} + +#[test] +fn lambdas_outside_higher_order_functions_are_rejected() { + let s = session(); + let e = error(&s, "SELECT upper(x -> x) AS v"); + assert_eq!( + e.error_class(), + ErrorClass::InvalidLambdaFunctionCallNonHigherOrderFunction + ); + assert_eq!(e.sql_state(), Some("42K0D")); + assert!(e.to_string().contains( + "org.apache.spark.sql.catalyst.expressions.Upper, which is not a higher order function" + )); + let e = error(&s, "SELECT ceil(x -> x) AS v"); + assert_eq!( + e.error_class(), + ErrorClass::InvalidLambdaFunctionCallNonHigherOrderFunction + ); + assert!( + e.to_string() + .contains("org.apache.spark.sql.catalyst.expressions.CeilExpressionBuilder$") + ); + // A bare lambda binds its body without variables first (which fails), + // so it stays unresolved rather than reaching the lambda check. + let e = error(&s, "SELECT x -> x AS v"); + assert_eq!( + e.error_class(), + ErrorClass::UnresolvedColumnWithoutSuggestion + ); +} + +#[test] +fn constant_lambdas_of_the_wrong_type_are_rejected() { + let s = session(); + for name in ["filter", "exists", "forall"] { + let e = error(&s, &format!("SELECT {name}(array(1, 2, 3), 1) AS v")); + assert_eq!( + e.error_class(), + ErrorClass::DatatypeMismatchUnexpectedInputType, + "{name}" + ); + assert_eq!(e.sql_state(), Some("42K09")); + assert_eq!( + e.to_string(), + format!( + "[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve \ + \"{name}(array(1, 2, 3), lambdafunction(1, namedlambdavariable()))\" \ + due to data type mismatch: The second parameter requires the \"BOOLEAN\" type, \ + however lambdafunction(1, namedlambdavariable()) has the type \"INT\". SQLSTATE: 42K09" + ) + ); + } + // The array argument is checked first: it needs `ARRAY`. + let e = error(&s, "SELECT transform(1, x -> x) AS v"); + assert_eq!( + e.error_class(), + ErrorClass::DatatypeMismatchUnexpectedInputType + ); + assert_eq!( + e.to_string(), + "[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve \ + \"transform(1, lambdafunction(x, x))\" due to data type mismatch: \ + The first parameter requires the \"ARRAY\" type, however \"1\" has the type \"INT\". SQLSTATE: 42K09" + ); +} + +#[test] +fn lambda_shapes_are_checked() { + let s = session(); + // `transform` takes one or two variables, the others exactly one. + let e = error(&s, "SELECT transform(ys, (a, b, c) -> a) FROM t"); + assert_eq!( + e.error_class(), + ErrorClass::InvalidLambdaFunctionCallNumArgsMismatch + ); + let e = error(&s, "SELECT filter(ys, (a, b) -> a) FROM t"); + assert_eq!( + e.error_class(), + ErrorClass::InvalidLambdaFunctionCallNumArgsMismatch + ); + // Duplicate variables. + let e = error(&s, "SELECT transform(ys, (a, a) -> a) FROM t"); + assert_eq!( + e.error_class(), + ErrorClass::InvalidLambdaFunctionCallDuplicateArgNames + ); + // Arity of the call itself. + let e = error(&s, "SELECT transform(ys) FROM t"); + assert_eq!(e.error_class(), ErrorClass::WrongNumArgsWithoutSuggestion); + // Aggregates and windows stay outside lambda bodies. + let e = error(&s, "SELECT transform(ys, y -> sum(y)) FROM t"); + assert_eq!(e.error_class(), ErrorClass::KrishivUnsupportedFeature); + let e = error( + &s, + "SELECT transform(ys, y -> rank() OVER (ORDER BY n)) FROM t", + ); + assert_eq!(e.error_class(), ErrorClass::KrishivUnsupportedFeature); +} + +#[test] +fn higher_order_output_names_and_types() { + let s = session(); + let df = block_on(s.sql("SELECT transform(ys, y -> y + 1) FROM t")).unwrap(); + let schema = block_on(df.schema()).unwrap(); + let field = &schema.fields()[0]; + assert_eq!( + DataType::from_arrow_field(field).unwrap(), + DataType::Array(ArrayType::new(DataType::Integer, false).into()) + ); + // Spark's `toPrettySQL` names. + let batches = block_on(df.collect()).unwrap(); + assert_eq!( + batches[0].schema().field(0).name(), + "transform(ys, lambdafunction((y + 1), y))" + ); +} diff --git a/crates/krishiv-sql/src/lower.rs b/crates/krishiv-sql/src/lower.rs index 5dd489f79..924a36459 100644 --- a/crates/krishiv-sql/src/lower.rs +++ b/crates/krishiv-sql/src/lower.rs @@ -1527,7 +1527,11 @@ impl Lowerer { ExprKind::Collate(..) => return Err(unsupported("COLLATE", sp)), ExprKind::VariantGet(..) => return Err(unsupported("variant paths", sp)), ExprKind::TableArgument(_) => return Err(unsupported("TABLE arguments", sp)), - ExprKind::Lambda { .. } => return Err(unsupported("lambda functions", sp)), + ExprKind::Lambda { params, body } => { + let params = params.iter().map(|p| p.value.clone()).collect(); + let body = self.arg(body)?; + self.ex(ExprNode::Lambda { params, body }, sp) + } ExprKind::Row(_) | ExprKind::Struct(_) => { return Err(unsupported("row and struct constructors", sp)); } diff --git a/crates/krishiv-sql/tests/snapshots/lower__constructs_lower_or_are_named_as_unsupported.snap b/crates/krishiv-sql/tests/snapshots/lower__constructs_lower_or_are_named_as_unsupported.snap index e44be4d7c..e212cf444 100644 --- a/crates/krishiv-sql/tests/snapshots/lower__constructs_lower_or_are_named_as_unsupported.snap +++ b/crates/krishiv-sql/tests/snapshots/lower__constructs_lower_or_are_named_as_unsupported.snap @@ -1,5 +1,6 @@ --- source: crates/krishiv-sql/tests/lower.rs +assertion_line: 51 expression: "report(&[\"SELECT 1\", \"SELECT DISTINCT a FROM t\",\n\"SELECT /*+ BROADCAST(t) */ a FROM t\",\n\"SELECT a FROM t UNION SELECT a FROM u\", \"VALUES (1)\",\n\"SELECT * FROM VALUES (1) AS v(a)\", \"SELECT * FROM range(3)\",\n\"SELECT a FROM t LATERAL VIEW explode(b) x AS y\",\n\"SELECT row_number() OVER (ORDER BY a) FROM t\",\n\"SELECT a FROM t GROUP BY ROLLUP (a)\", \"SELECT a FROM t GROUP BY a WITH CUBE\",\n\"SELECT * FROM t NATURAL JOIN u\", \"SELECT * FROM t, LATERAL (SELECT a)\",\n\"SELECT * FROM t VERSION AS OF 1\", \"SELECT a FROM t CLUSTER BY a\",\n\"SELECT a FROM t DISTRIBUTE BY a\", \"SELECT a FROM t LIMIT 1 OFFSET 2\",\n\"FROM t SELECT a LIMIT 1 OFFSET 2\", \"FROM t SELECT a CLUSTER BY a\",\n\"FROM t SELECT a DISTRIBUTE BY a\", \"FROM t SELECT a WINDOW w AS (ORDER BY a)\",\n\"SELECT a FROM t WINDOW w AS (ORDER BY a)\", \"SELECT a FROM t QUALIFY a > 1\",\n\"WITH RECURSIVE r AS (SELECT a FROM t) SELECT * FROM r\",\n\"SELECT * EXCEPT (a) FROM t\", \"SELECT a FROM t INTERSECT SELECT a FROM u\",\n\"SELECT a FROM t EXCEPT ALL SELECT a FROM u\",\n\"SELECT /*+ BROADCAST(t), MERGE(u) */ /*+ COALESCE(2) */ DISTINCT a FROM t, u\",\n\"SELECT a FROM t UNION ALL SELECT b FROM u UNION SELECT c FROM v\",\n\"SELECT x[0] FROM t\", \"SELECT (a).b.c FROM t\", \"SELECT f(a).b FROM t\",\n\"SELECT transform(a, x -> x) FROM t\", \"SELECT (a, b) FROM t\",\n\"SELECT a LIKE ANY ('x', 'y') FROM t\", \"SELECT ? FROM t\",\n\"SELECT INTERVAL 1 DAY FROM t\",\n\"SELECT TIMESTAMP '2020-01-01 00:00:00' FROM t\", \"SELECT db.f(a) FROM t\",\n\"SELECT f(x => 1) FROM t\",\n\"SELECT percentile_cont(0.5) WITHIN GROUP (ORDER BY a) FROM t\",\n\"SELECT sum(a) IGNORE NULLS FROM t\", \"SELECT * FROM t WITH (k = x)\",\n\"FROM t SELECT a SELECT b\",\n\"SELECT * FROM parquet.`s3a://k:Canary-7f3a9c@b/p` WITH ('password' = 'Canary-7f3a9c')\",\n\"WITH c (x) AS (SELECT a FROM t) SELECT x FROM c ORDER BY x LIMIT ALL\",\n\"FROM t SELECT a SORT BY a\",\n\"SELECT a FROM t WHERE (a, b) IN (SELECT a, d FROM u) AND a NOT BETWEEN 1 AND 2\",\n\"SELECT a <=> 1, a IS DISTINCT FROM 1, a IS NOT DISTINCT FROM 1, a IS TRUE, a IS NOT FALSE, a IS UNKNOWN, a IS NOT UNKNOWN FROM t\",\n\"SELECT +a, ~a, a DIV 2, a & 1, a | 1, a ^ 1, a << 1, a >> 1, a >>> 1, a || b FROM t\",\n\"SELECT CASE a WHEN 1 THEN 'x' END, b ILIKE 'x' ESCAPE '/', b NOT RLIKE 'x', TRY_CAST(a AS INT) FROM t\",\n\"SELECT * FROM (t JOIN u ON true) x CROSS JOIN v LEFT SEMI JOIN w ON true\",\n\"TABLE t\", \"(SELECT a FROM t) ORDER BY a\", \"FROM t SELECT a UNION SELECT b\",\n\"WITH RECURSIVE c MAX RECURSION LEVEL 3 AS (SELECT a FROM t) SELECT a FROM c\",\n\"SELECT explode(a) AS (x, y) FROM t\",\n\"SELECT * FROM t JOIN LATERAL (SELECT a) s\",\n\"SELECT * FROM t WITH (k = true, n = 2) RIGHT JOIN (SELECT a FROM u) USING (a)\",\n\"SELECT -a, a % 2, a IS NULL, NULL FROM t ORDER BY a DESC NULLS FIRST, b NULLS LAST\",\n\"SELECT (t.a).b, ((a)).c.d FROM t\", \"SELECT 1BD, 1e3BD FROM t\",])" --- SELECT 1 @@ -67,7 +68,7 @@ SELECT (a).b.c FROM t SELECT f(a).b FROM t => [KRISHIV_UNSUPPORTED_FEATURE] The feature field access on an expression is not supported by Krishiv yet. SQLSTATE: 0A000 @ 7..13 SELECT transform(a, x -> x) FROM t - => [KRISHIV_UNSUPPORTED_FEATURE] The feature lambda functions is not supported by Krishiv yet. SQLSTATE: 0A000 @ 20..26 + => Project [transform(a, (x) -> x)] | +- Read t | SELECT (a, b) FROM t => [KRISHIV_UNSUPPORTED_FEATURE] The feature row and struct constructors is not supported by Krishiv yet. SQLSTATE: 0A000 @ 7..13 SELECT a LIKE ANY ('x', 'y') FROM t diff --git a/crates/krishiv-testkit/src/golden/session_engine.rs b/crates/krishiv-testkit/src/golden/session_engine.rs index cdb111b28..9a1334418 100644 --- a/crates/krishiv-testkit/src/golden/session_engine.rs +++ b/crates/krishiv-testkit/src/golden/session_engine.rs @@ -364,6 +364,194 @@ fn arrow_cell(col: &ArrayRef, row: usize, ty: &DataType) -> Result { Cell::TimestampNtz(col.as_primitive::().value(row)) } + (DataType::Array(element), ArrowType::List(_) | ArrowType::LargeList(_)) => { + Cell::Array(list_cells(col, row, element)?) + } + (DataType::Map(map), ArrowType::Map(..)) => map_cell(col, row, map)?, + (DataType::Struct(struct_), ArrowType::Struct(_)) => struct_cell(col, row, struct_)?, + _ => return Err(unexpected()), + }) +} + +/// The elements of the list at `row` of `col` (a `List` or `LargeList`) as +/// cells of the element type. +fn list_cells( + col: &ArrayRef, + row: usize, + element: &krishiv_types::ArrayType, +) -> Result, EngineError> { + let (start, stop, values) = match col.data_type() { + ArrowType::List(_) => { + let list = col.as_list::(); + ( + usize::try_from(list.value_offsets()[row]).map_err(|_| { + harness_error("a nested list with a negative offset".to_owned()) + })?, + usize::try_from(list.value_offsets()[row + 1]).map_err(|_| { + harness_error("a nested list with a negative offset".to_owned()) + })?, + Arc::clone(list.values()), + ) + } + ArrowType::LargeList(_) => { + let list = col.as_list::(); + ( + usize::try_from(list.value_offsets()[row]) + .map_err(|_| harness_error("a nested list with a bad offset".to_owned()))?, + usize::try_from(list.value_offsets()[row + 1]) + .map_err(|_| harness_error("a nested list with a bad offset".to_owned()))?, + Arc::clone(list.values()), + ) + } + other => { + return Err(harness_error(format!( + "Arrow type {other} for {}", + DataType::Array(Arc::new(element.clone())).catalog_string() + ))); + } + }; + (start..stop) + .map(|i| nested_cell(&values, i, element.element_type())) + .collect() +} + +/// The map at `row` of `col` as key/value cells in storage order (the +/// renderer sorts them as Spark does). +fn map_cell(col: &ArrayRef, row: usize, map: &krishiv_types::MapType) -> Result { + let ArrowType::Map(entries, _) = col.data_type() else { + return Err(harness_error(format!( + "Arrow type {} for {}", + col.data_type(), + DataType::Map(Arc::new(map.clone())).catalog_string() + ))); + }; + let ArrowType::Struct(kv) = entries.data_type() else { + return Err(harness_error(format!( + "Arrow map entries {}", + entries.data_type() + ))); + }; + if kv.len() != 2 { + return Err(harness_error(format!( + "Arrow map entries {}", + entries.data_type() + ))); + } + let entries = col.as_map(); + let (start, stop) = ( + usize::try_from(entries.value_offsets()[row]) + .map_err(|_| harness_error("a nested map with a negative offset".to_owned()))?, + usize::try_from(entries.value_offsets()[row + 1]) + .map_err(|_| harness_error("a nested map with a negative offset".to_owned()))?, + ); + let keys = entries.keys(); + let values = entries.values(); + (start..stop) + .map(|i| { + Ok(( + nested_cell(keys, i, map.key_type())?, + nested_cell(values, i, map.value_type())?, + )) + }) + .collect::, _>>() + .map(Cell::Map) +} + +/// The struct at `row` of `col` as its fields' cells. +fn struct_cell( + col: &ArrayRef, + row: usize, + struct_: &krishiv_types::StructType, +) -> Result { + let ArrowType::Struct(fields) = col.data_type() else { + return Err(harness_error(format!( + "Arrow type {} for {}", + col.data_type(), + DataType::Struct(struct_.clone()).catalog_string() + ))); + }; + let values = col.as_struct(); + if fields.len() != struct_.fields().len() { + return Err(harness_error(format!( + "Arrow struct {} for {}", + col.data_type(), + DataType::Struct(struct_.clone()).catalog_string() + ))); + } + struct_ + .fields() + .iter() + .zip(fields.iter()) + .enumerate() + .map(|(i, (f, _))| { + Ok(( + f.name().to_owned(), + nested_cell(values.column(i), row, f.data_type())?, + )) + }) + .collect::, _>>() + .map(Cell::Struct) +} + +/// The value at `row` of `col`, a (possibly nested) value of Spark type +/// `ty`, as a cell. NULLs are `Null` at every level. +fn nested_cell(col: &ArrayRef, row: usize, ty: &DataType) -> Result { + if col.is_null(row) { + return Ok(Cell::Null); + } + let unexpected = || { + harness_error(format!( + "Arrow type {} for {}", + col.data_type(), + ty.catalog_string() + )) + }; + Ok(match (ty, col.data_type()) { + (DataType::Null, _) => Cell::Null, + (DataType::Boolean, ArrowType::Boolean) => Cell::Bool(col.as_boolean().value(row)), + (DataType::Byte, ArrowType::Int8) => { + Cell::Int(i64::from(col.as_primitive::().value(row))) + } + (DataType::Short, ArrowType::Int16) => { + Cell::Int(i64::from(col.as_primitive::().value(row))) + } + (DataType::Integer, ArrowType::Int32) => { + Cell::Int(i64::from(col.as_primitive::().value(row))) + } + (DataType::Long, ArrowType::Int64) => Cell::Int(col.as_primitive::().value(row)), + (DataType::Float, ArrowType::Float32) => { + Cell::Float(col.as_primitive::().value(row)) + } + (DataType::Double, ArrowType::Float64) => { + Cell::Double(col.as_primitive::().value(row)) + } + (DataType::Decimal(d), ArrowType::Decimal128(..)) => Cell::Decimal( + col.as_primitive::().value(row), + u32::from(d.scale()), + ), + (DataType::String, ArrowType::Utf8View) => { + Cell::Str(col.as_string_view().value(row).to_owned()) + } + (DataType::String, ArrowType::Utf8) => { + Cell::Str(col.as_string::().value(row).to_owned()) + } + (DataType::String, ArrowType::LargeUtf8) => { + Cell::Str(col.as_string::().value(row).to_owned()) + } + (DataType::Date, ArrowType::Date32) => { + Cell::Date(col.as_primitive::().value(row)) + } + (DataType::Timestamp, ArrowType::Timestamp(..)) => { + Cell::Timestamp(col.as_primitive::().value(row)) + } + (DataType::TimestampNtz, ArrowType::Timestamp(..)) => { + Cell::TimestampNtz(col.as_primitive::().value(row)) + } + (DataType::Array(element), ArrowType::List(_) | ArrowType::LargeList(_)) => { + Cell::Array(list_cells(col, row, element)?) + } + (DataType::Map(map), ArrowType::Map(..)) => map_cell(col, row, map)?, + (DataType::Struct(struct_), ArrowType::Struct(_)) => struct_cell(col, row, struct_)?, _ => return Err(unexpected()), }) } diff --git a/proto/krishiv/plan/v1/plan.proto b/proto/krishiv/plan/v1/plan.proto index 44412ebba..c5656e095 100644 --- a/proto/krishiv/plan/v1/plan.proto +++ b/proto/krishiv/plan/v1/plan.proto @@ -551,9 +551,21 @@ message Expr { Function function = 5; Cast cast = 6; AliasExpr alias = 7; + // feature: lambda_functions + Lambda lambda = 8; + // feature: lambda_functions + BoundColumn lambda_var = 9; } } +// A lambda (`x -> body`): the bound body of a higher-order function's +// argument, with its variables as `lambda_var` leaves. +// feature: lambda_functions +message Lambda { + repeated string params = 1; + uint32 body = 2; +} + message AliasExpr { uint32 expr = 1; BoundColumn output = 2; diff --git a/python/krishiv/sql/_generated_functions.py b/python/krishiv/sql/_generated_functions.py index fadef4b1e..72a54a8e2 100644 --- a/python/krishiv/sql/_generated_functions.py +++ b/python/krishiv/sql/_generated_functions.py @@ -29,6 +29,7 @@ "acos", "acosh", "add_months", + "array", "asin", "asinh", "assert_true", @@ -223,6 +224,11 @@ def add_months(start: ColumnOrName, months: ColumnOrName | int) -> Column: return _call("add_months", _named(start, "start"), _int_or_col(months, "months")) +def array(*cols: ColumnOrName) -> Column: + """Calls the registry function ``array``.""" + return _call("array", *_cols(cols)) + + def asin(col: ColumnOrName) -> Column: """Calls the registry function ``asin``.""" return _call("asin", _named(col, "col")) diff --git a/python/krishiv/sql/_generated_functions.pyi b/python/krishiv/sql/_generated_functions.pyi index bfa34d37b..a01194eda 100644 --- a/python/krishiv/sql/_generated_functions.pyi +++ b/python/krishiv/sql/_generated_functions.pyi @@ -10,6 +10,7 @@ __all__ = [ "acos", "acosh", "add_months", + "array", "asin", "asinh", "assert_true", @@ -187,6 +188,7 @@ def abs(col: ColumnOrName) -> Column: ... def acos(col: ColumnOrName) -> Column: ... def acosh(col: ColumnOrName) -> Column: ... def add_months(start: ColumnOrName, months: ColumnOrName | int) -> Column: ... +def array(*cols: ColumnOrName) -> Column: ... def asin(col: ColumnOrName) -> Column: ... def asinh(col: ColumnOrName) -> Column: ... def assert_true(col: ColumnOrName, errMsg: Column | str | None = None) -> Column: ... diff --git a/python/tests/_pyspark_signatures.py b/python/tests/_pyspark_signatures.py index 4ec4722d4..e5bbbe997 100644 --- a/python/tests/_pyspark_signatures.py +++ b/python/tests/_pyspark_signatures.py @@ -13,6 +13,7 @@ "acos": "col", "acosh": "col", "add_months": "start, months", + "array": "*cols", "asc": "col", "asin": "col", "asinh": "col", diff --git a/tests/fixtures/analysis/registry-matrix/%26.json b/tests/fixtures/analysis/registry-matrix/%26.json index 7df1f0f43..4ca042c56 100644 --- a/tests/fixtures/analysis/registry-matrix/%26.json +++ b/tests/fixtures/analysis/registry-matrix/%26.json @@ -32,14 +32,6 @@ "id": "ᘛa97d9ba4/ansi_off", "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) & 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "៫fc249fec/ansi_on", - "reason": "SELECT 3 & (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "៫fc249fec/ansi_off", - "reason": "SELECT 3 & (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "ff00391103b/ansi_on", "reason": "SELECT (INTERVAL '1 02:03:04' DAY TO SECOND) & 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" @@ -56,14 +48,6 @@ "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" - }, - { - "id": "&#c2f3c9f79da5/ansi_off", - "reason": "SELECT (array(1, 2)) & 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "&#c5402653e378/ansi_on", "reason": "SELECT 3 & (INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/%3C%3C.json b/tests/fixtures/analysis/registry-matrix/%3C%3C.json index fc7c47131..1d56ec62a 100644 --- a/tests/fixtures/analysis/registry-matrix/%3C%3C.json +++ b/tests/fixtures/analysis/registry-matrix/%3C%3C.json @@ -8,14 +8,6 @@ "id": "<<#1dacd979bb38/ansi_off", "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) << 1 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "<<#414a74fe9693/ansi_on", - "reason": "SELECT 2 << (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "<<#414a74fe9693/ansi_off", - "reason": "SELECT 2 << (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "<<#5564cec7503a/ansi_on", "reason": "SELECT 2 << (INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,6 @@ "id": "<<#7e74e30d017a/ansi_off", "reason": "SELECT 2 << (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "<<#83a6d37169a0/ansi_on", - "reason": "SELECT (array(1, 2)) << 1 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "<<#83a6d37169a0/ansi_off", - "reason": "SELECT (array(1, 2)) << 1 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "<<#b68d0e5fe063/ansi_on", "reason": "SELECT 2 << (map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json b/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json index e987e9cc5..c6be2c1b6 100644 --- a/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json +++ b/tests/fixtures/analysis/registry-matrix/%3E%3E%3E.json @@ -55,14 +55,6 @@ { "id": ">>>#d2b78b328d9c/ansi_off", "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) >>> 1 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": ">>>#daf9cb7bc89b/ansi_on", - "reason": "SELECT 4 >>> (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": ">>>#daf9cb7bc89b/ansi_off", - "reason": "SELECT 4 >>> (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/%3E%3E.json b/tests/fixtures/analysis/registry-matrix/%3E%3E.json index f551bf684..0ecd1aa83 100644 --- a/tests/fixtures/analysis/registry-matrix/%3E%3E.json +++ b/tests/fixtures/analysis/registry-matrix/%3E%3E.json @@ -55,14 +55,6 @@ { "id": ">>#cd095b9581fc/ansi_off", "reason": "SELECT 4 >> (named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": ">>#f7b11ad82d07/ansi_on", - "reason": "SELECT 4 >> (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": ">>#f7b11ad82d07/ansi_off", - "reason": "SELECT 4 >> (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/%5E.json b/tests/fixtures/analysis/registry-matrix/%5E.json index 23242bcad..8bb07d444 100644 --- a/tests/fixtures/analysis/registry-matrix/%5E.json +++ b/tests/fixtures/analysis/registry-matrix/%5E.json @@ -24,22 +24,6 @@ "id": "^#2e9b5ee868b2/ansi_off", "reason": "SELECT 3 ^ (INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "^#4afd3e5c8033/ansi_on", - "reason": "SELECT (array(1, 2)) ^ 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "^#4afd3e5c8033/ansi_off", - "reason": "SELECT (array(1, 2)) ^ 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "^#4b155c91bb5a/ansi_on", - "reason": "SELECT 3 ^ (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "^#4b155c91bb5a/ansi_off", - "reason": "SELECT 3 ^ (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "^#83d0d49f9f79/ansi_on", "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) ^ 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/%7C.json b/tests/fixtures/analysis/registry-matrix/%7C.json index 16cc7ced2..6b2c19b27 100644 --- a/tests/fixtures/analysis/registry-matrix/%7C.json +++ b/tests/fixtures/analysis/registry-matrix/%7C.json @@ -24,22 +24,6 @@ "id": "|#4b4a45b36f81/ansi_off", "reason": "SELECT 3 | (INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "|#568823444782/ansi_on", - "reason": "SELECT (array(1, 2)) | 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "|#568823444782/ansi_off", - "reason": "SELECT (array(1, 2)) | 5 | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "|#8c3695b18e5d/ansi_on", - "reason": "SELECT 3 | (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "|#8c3695b18e5d/ansi_off", - "reason": "SELECT 3 | (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "|#97f196c58d5e/ansi_on", "reason": "SELECT (INTERVAL '1-2' YEAR TO MONTH) | 5 | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/%7E.json b/tests/fixtures/analysis/registry-matrix/%7E.json index 7028bdda9..6b3bcd7f9 100644 --- a/tests/fixtures/analysis/registry-matrix/%7E.json +++ b/tests/fixtures/analysis/registry-matrix/%7E.json @@ -31,14 +31,6 @@ { "id": "~#d7bb0f587adb/ansi_off", "reason": "SELECT ~ (named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "~#ff628d33811f/ansi_on", - "reason": "SELECT ~ (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "~#ff628d33811f/ansi_off", - "reason": "SELECT ~ (array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/abs.json b/tests/fixtures/analysis/registry-matrix/abs.json index 57ced4942..d59c6ee31 100644 --- a/tests/fixtures/analysis/registry-matrix/abs.json +++ b/tests/fixtures/analysis/registry-matrix/abs.json @@ -16,14 +16,6 @@ "id": "abs#259f8171392f/ansi_off", "reason": "SELECT abs(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "abs#482fd6fb3fb5/ansi_on", - "reason": "SELECT abs(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "abs#482fd6fb3fb5/ansi_off", - "reason": "SELECT abs(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "abs#5095fc57b734/ansi_on", "reason": "SELECT abs(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/acos.json b/tests/fixtures/analysis/registry-matrix/acos.json index ab31cfb4c..e446719af 100644 --- a/tests/fixtures/analysis/registry-matrix/acos.json +++ b/tests/fixtures/analysis/registry-matrix/acos.json @@ -16,14 +16,6 @@ "id": "acos#646618e3c77a/ansi_off", "reason": "SELECT acos(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "acos#87281b46e804/ansi_on", - "reason": "SELECT acos(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "acos#87281b46e804/ansi_off", - "reason": "SELECT acos(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "acos#9c26a0867994/ansi_on", "reason": "SELECT acos(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/acosh.json b/tests/fixtures/analysis/registry-matrix/acosh.json index d1a875267..e703dd122 100644 --- a/tests/fixtures/analysis/registry-matrix/acosh.json +++ b/tests/fixtures/analysis/registry-matrix/acosh.json @@ -8,14 +8,6 @@ "id": "acosh#3bee273b22bf/ansi_off", "reason": "SELECT acosh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "acosh#5a9d77ca8ad6/ansi_on", - "reason": "SELECT acosh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "acosh#5a9d77ca8ad6/ansi_off", - "reason": "SELECT acosh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "acosh#7395fd9dea44/ansi_on", "reason": "SELECT acosh(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/add_months.json b/tests/fixtures/analysis/registry-matrix/add_months.json index be37ab20a..88ba4a6f6 100644 --- a/tests/fixtures/analysis/registry-matrix/add_months.json +++ b/tests/fixtures/analysis/registry-matrix/add_months.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "add_months#1e08d6e1ace9/ansi_on", - "reason": "SELECT add_months(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "add_months#1e08d6e1ace9/ansi_off", - "reason": "SELECT add_months(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "add_months#22590bd13694/ansi_on", "reason": "SELECT add_months('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -24,14 +16,6 @@ "id": "add_months#244504d3ba66/ansi_off", "reason": "SELECT add_months('2016-08-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "add_months#2e88092bbf13/ansi_on", - "reason": "SELECT add_months('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "add_months#2e88092bbf13/ansi_off", - "reason": "SELECT add_months('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "add_months#59aa9c148f08/ansi_on", "reason": "SELECT add_months(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/any_value.json b/tests/fixtures/analysis/registry-matrix/any_value.json index e9e2879b6..c20f495c3 100644 --- a/tests/fixtures/analysis/registry-matrix/any_value.json +++ b/tests/fixtures/analysis/registry-matrix/any_value.json @@ -16,14 +16,6 @@ "id": "any_value#6188e23671f4/ansi_off", "reason": "SELECT any_value(col, map('a', 1)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" }, - { - "id": "any_value#94942fcbfe3e/ansi_on", - "reason": "SELECT any_value(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "any_value#94942fcbfe3e/ansi_off", - "reason": "SELECT any_value(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" - }, { "id": "any_value#a4824560fdf2/ansi_on", "reason": "SELECT any_value(col, named_struct('a', 1, 'b', 'x')) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has _LEGACY_ERROR_TEMP_1210" diff --git a/tests/fixtures/analysis/registry-matrix/array.json b/tests/fixtures/analysis/registry-matrix/array.json new file mode 100644 index 000000000..79db0b50c --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/array.json @@ -0,0 +1,102 @@ +{ + "entries": [ + { + "id": "array#35a6602b4e47/ansi_on", + "reason": "SELECT array(1, named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#35a6602b4e47/ansi_off", + "reason": "SELECT array(1, named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#3776c9b2bbb5/ansi_on", + "reason": "SELECT array(INTERVAL '1 02:03:04' DAY TO SECOND, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#3776c9b2bbb5/ansi_off", + "reason": "SELECT array(INTERVAL '1 02:03:04' DAY TO SECOND, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#3f4eb4621153/ansi_on", + "reason": "SELECT array(1, INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#3f4eb4621153/ansi_off", + "reason": "SELECT array(1, INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#48fcc0ee45af/ansi_on", + "reason": "SELECT array(1, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#48fcc0ee45af/ansi_off", + "reason": "SELECT array(1, 2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#4e48d4c1b9eb/ansi_on", + "reason": "SELECT array(1, 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#4e48d4c1b9eb/ansi_off", + "reason": "SELECT array(1, 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#56b5cfdc3f32/ansi_on", + "reason": "SELECT array(1, INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#56b5cfdc3f32/ansi_off", + "reason": "SELECT array(1, INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#69efbf1e4dd3/ansi_on", + "reason": "SELECT array(1, 2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#69efbf1e4dd3/ansi_off", + "reason": "SELECT array(1, 2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#8037a1c4aa19/ansi_on", + "reason": "SELECT array(named_struct('a', 1, 'b', 'x'), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#8037a1c4aa19/ansi_off", + "reason": "SELECT array(named_struct('a', 1, 'b', 'x'), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#9cfb954ccb6e/ansi_on", + "reason": "SELECT array(1, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#9cfb954ccb6e/ansi_off", + "reason": "SELECT array(1, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#bbc3db311e18/ansi_on", + "reason": "SELECT array(map('a', 1), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#bbc3db311e18/ansi_off", + "reason": "SELECT array(map('a', 1), 2, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#e4bd5d8105fe/ansi_on", + "reason": "SELECT array(1, 2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#e4bd5d8105fe/ansi_off", + "reason": "SELECT array(1, 2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#eaa2a4fe5b08/ansi_on", + "reason": "SELECT array(INTERVAL '1-2' YEAR TO MONTH, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + }, + { + "id": "array#eaa2a4fe5b08/ansi_off", + "reason": "SELECT array(INTERVAL '1-2' YEAR TO MONTH, 2, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" + } + ], + "format_version": 1, + "function": "array" +} diff --git a/tests/fixtures/analysis/registry-matrix/asin.json b/tests/fixtures/analysis/registry-matrix/asin.json index bca3af4d1..ec26dce0b 100644 --- a/tests/fixtures/analysis/registry-matrix/asin.json +++ b/tests/fixtures/analysis/registry-matrix/asin.json @@ -31,14 +31,6 @@ { "id": "asin#9782577ff91e/ansi_off", "reason": "SELECT asin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "asin#c049095f4686/ansi_on", - "reason": "SELECT asin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "asin#c049095f4686/ansi_off", - "reason": "SELECT asin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/asinh.json b/tests/fixtures/analysis/registry-matrix/asinh.json index bf15c4236..8ddb0c6b7 100644 --- a/tests/fixtures/analysis/registry-matrix/asinh.json +++ b/tests/fixtures/analysis/registry-matrix/asinh.json @@ -8,14 +8,6 @@ "id": "asinh#46c7e19729ea/ansi_off", "reason": "SELECT asinh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "asinh#65a403e1a21d/ansi_on", - "reason": "SELECT asinh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "asinh#65a403e1a21d/ansi_off", - "reason": "SELECT asinh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "asinh#68bed1327e2a/ansi_on", "reason": "SELECT asinh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/assert_true.json b/tests/fixtures/analysis/registry-matrix/assert_true.json index 3e27eb0b3..16b10ffe1 100644 --- a/tests/fixtures/analysis/registry-matrix/assert_true.json +++ b/tests/fixtures/analysis/registry-matrix/assert_true.json @@ -31,14 +31,6 @@ { "id": "assert_true#ba638b11eda1/ansi_off", "reason": "SELECT assert_true(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "assert_true#f08d6b05e52f/ansi_on", - "reason": "SELECT assert_true(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "assert_true#f08d6b05e52f/ansi_off", - "reason": "SELECT assert_true(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/atan.json b/tests/fixtures/analysis/registry-matrix/atan.json index 37bcf8e7d..289806789 100644 --- a/tests/fixtures/analysis/registry-matrix/atan.json +++ b/tests/fixtures/analysis/registry-matrix/atan.json @@ -31,14 +31,6 @@ { "id": "atan#b9bb1209d291/ansi_off", "reason": "SELECT atan(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "atan#f34317d2890d/ansi_on", - "reason": "SELECT atan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "atan#f34317d2890d/ansi_off", - "reason": "SELECT atan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/atan2.json b/tests/fixtures/analysis/registry-matrix/atan2.json index d6c7192d2..0491d5761 100644 --- a/tests/fixtures/analysis/registry-matrix/atan2.json +++ b/tests/fixtures/analysis/registry-matrix/atan2.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "atan2#0cec7ecf11ad/ansi_on", - "reason": "SELECT atan2(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "atan2#0cec7ecf11ad/ansi_off", - "reason": "SELECT atan2(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "atan2#2efc7af90017/ansi_on", "reason": "SELECT atan2(0, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -71,14 +63,6 @@ { "id": "atan2#ba98c7f801fa/ansi_off", "reason": "SELECT atan2(0, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "atan2#ead386e08f1b/ansi_on", - "reason": "SELECT atan2(0, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "atan2#ead386e08f1b/ansi_off", - "reason": "SELECT atan2(0, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/atanh.json b/tests/fixtures/analysis/registry-matrix/atanh.json index 9c8130ab9..c13991253 100644 --- a/tests/fixtures/analysis/registry-matrix/atanh.json +++ b/tests/fixtures/analysis/registry-matrix/atanh.json @@ -31,14 +31,6 @@ { "id": "atanh#8aee7e3f3cdc/ansi_off", "reason": "SELECT atanh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "atanh#8af9637d5218/ansi_on", - "reason": "SELECT atanh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "atanh#8af9637d5218/ansi_off", - "reason": "SELECT atanh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/bin.json b/tests/fixtures/analysis/registry-matrix/bin.json index afe4e4308..7b5559f69 100644 --- a/tests/fixtures/analysis/registry-matrix/bin.json +++ b/tests/fixtures/analysis/registry-matrix/bin.json @@ -31,14 +31,6 @@ { "id": "bin#a90cb066faf8/ansi_off", "reason": "SELECT bin(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bin#b71e669879a6/ansi_on", - "reason": "SELECT bin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bin#b71e669879a6/ansi_off", - "reason": "SELECT bin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/bit_count.json b/tests/fixtures/analysis/registry-matrix/bit_count.json index 5e33ec31c..fd60eba6f 100644 --- a/tests/fixtures/analysis/registry-matrix/bit_count.json +++ b/tests/fixtures/analysis/registry-matrix/bit_count.json @@ -31,14 +31,6 @@ { "id": "bit_count#b49e21523e6e/ansi_off", "reason": "SELECT bit_count(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bit_count#dc4f784b72ec/ansi_on", - "reason": "SELECT bit_count(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bit_count#dc4f784b72ec/ansi_off", - "reason": "SELECT bit_count(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/bit_get.json b/tests/fixtures/analysis/registry-matrix/bit_get.json index b61eb7a52..09571322a 100644 --- a/tests/fixtures/analysis/registry-matrix/bit_get.json +++ b/tests/fixtures/analysis/registry-matrix/bit_get.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "bit_get#09f72caf9f6d/ansi_on", - "reason": "SELECT bit_get(11, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bit_get#09f72caf9f6d/ansi_off", - "reason": "SELECT bit_get(11, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "bit_get#1cfd4b0fa7e1/ansi_on", "reason": "SELECT bit_get(INTERVAL '1-2' YEAR TO MONTH, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,6 @@ "id": "bit_get#9e9ba98e7b02/ansi_off", "reason": "SELECT bit_get(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "bit_get#a304d611b3ac/ansi_on", - "reason": "SELECT bit_get(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bit_get#a304d611b3ac/ansi_off", - "reason": "SELECT bit_get(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "bit_get#ce44b5105527/ansi_on", "reason": "SELECT bit_get(11, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/bround.json b/tests/fixtures/analysis/registry-matrix/bround.json index f4d1971b8..9c20b34b3 100644 --- a/tests/fixtures/analysis/registry-matrix/bround.json +++ b/tests/fixtures/analysis/registry-matrix/bround.json @@ -32,14 +32,6 @@ "id": "bround#61b3210c3a84/ansi_off", "reason": "SELECT bround(2.5, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "bround#6b63892f457c/ansi_on", - "reason": "SELECT bround(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bround#6b63892f457c/ansi_off", - "reason": "SELECT bround(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "bround#8139bd9fdb4c/ansi_on", "reason": "SELECT bround(2.5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +56,6 @@ "id": "bround#972098065b06/ansi_off", "reason": "SELECT bround(2.5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "bround#b53e747128fc/ansi_on", - "reason": "SELECT bround(2.5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "bround#b53e747128fc/ansi_off", - "reason": "SELECT bround(2.5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "bround#e536627ae66a/ansi_on", "reason": "SELECT bround(2.5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/btrim.json b/tests/fixtures/analysis/registry-matrix/btrim.json index 92e9ab492..d9c8640b0 100644 --- a/tests/fixtures/analysis/registry-matrix/btrim.json +++ b/tests/fixtures/analysis/registry-matrix/btrim.json @@ -80,30 +80,6 @@ "id": "btrim#63c2c80017bb/ansi_off", "reason": "SELECT btrim(encode(' SparkSQL ', 'utf-8')) | KRISHIV_UNSUPPORTED_FEATURE: function encode" }, - { - "id": "btrim#6f1102cdc0c2/ansi_on", - "reason": "SELECT btrim(array(1, 2), 'SL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "btrim#6f1102cdc0c2/ansi_off", - "reason": "SELECT btrim(array(1, 2), 'SL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "btrim#712992317d38/ansi_on", - "reason": "SELECT btrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "btrim#712992317d38/ansi_off", - "reason": "SELECT btrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "btrim#71e5a8cb22b3/ansi_on", - "reason": "SELECT btrim('SSparkSQLS', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "btrim#71e5a8cb22b3/ansi_off", - "reason": "SELECT btrim('SSparkSQLS', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "btrim#812b69ba8fda/ansi_on", "reason": "SELECT btrim('SSparkSQLS', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/cbrt.json b/tests/fixtures/analysis/registry-matrix/cbrt.json index 953c55a64..67bc135f7 100644 --- a/tests/fixtures/analysis/registry-matrix/cbrt.json +++ b/tests/fixtures/analysis/registry-matrix/cbrt.json @@ -24,14 +24,6 @@ "id": "cbrt#9709bdf461bb/ansi_off", "reason": "SELECT cbrt(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "cbrt#b0ead4e731f4/ansi_on", - "reason": "SELECT cbrt(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "cbrt#b0ead4e731f4/ansi_off", - "reason": "SELECT cbrt(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "cbrt#fdb007bf9143/ansi_on", "reason": "SELECT cbrt(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/ceil.json b/tests/fixtures/analysis/registry-matrix/ceil.json index 9db77cf58..8f84586b0 100644 --- a/tests/fixtures/analysis/registry-matrix/ceil.json +++ b/tests/fixtures/analysis/registry-matrix/ceil.json @@ -8,14 +8,6 @@ "id": "ceil#1fccd13497ba/ansi_off", "reason": "SELECT ceil(3.1411, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has NON_FOLDABLE_ARGUMENT" }, - { - "id": "ceil#2f7b08117092/ansi_on", - "reason": "SELECT ceil(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT" - }, - { - "id": "ceil#2f7b08117092/ansi_off", - "reason": "SELECT ceil(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT" - }, { "id": "ceil#3ed3ac5ba694/ansi_on", "reason": "SELECT ceil(named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,6 @@ "id": "ceil#5b3a37a449f4/ansi_off", "reason": "SELECT ceil(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "ceil#68dccc710861/ansi_on", - "reason": "SELECT ceil(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ceil#68dccc710861/ansi_off", - "reason": "SELECT ceil(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ceil#7b7739e2b4bb/ansi_on", "reason": "SELECT ceil(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -88,14 +72,6 @@ "id": "ceil#ca364ac004a2/ansi_off", "reason": "SELECT ceil(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "ceil#e8617ac2cc62/ansi_on", - "reason": "SELECT ceil(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ceil#e8617ac2cc62/ansi_off", - "reason": "SELECT ceil(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ceil#ead4d6922dcb/ansi_on", "reason": "SELECT ceil(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/ceiling.json b/tests/fixtures/analysis/registry-matrix/ceiling.json index a79ebdf8b..9085d3046 100644 --- a/tests/fixtures/analysis/registry-matrix/ceiling.json +++ b/tests/fixtures/analysis/registry-matrix/ceiling.json @@ -8,14 +8,6 @@ "id": "ceiling#0af50c72a6d8/ansi_off", "reason": "SELECT ceiling(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "ceiling#20bc43388a99/ansi_on", - "reason": "SELECT ceiling(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ceiling#20bc43388a99/ansi_off", - "reason": "SELECT ceiling(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ceiling#2874737e9ad9/ansi_on", "reason": "SELECT ceiling(named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,6 @@ "id": "ceiling#523bf03f299a/ansi_off", "reason": "SELECT ceiling(3.1411, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has NON_FOLDABLE_ARGUMENT" }, - { - "id": "ceiling#63e6ed7b8d9f/ansi_on", - "reason": "SELECT ceiling(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ceiling#63e6ed7b8d9f/ansi_off", - "reason": "SELECT ceiling(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ceiling#6bd7751202b6/ansi_on", "reason": "SELECT ceiling(3.1411, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has NON_FOLDABLE_ARGUMENT" @@ -88,14 +72,6 @@ "id": "ceiling#c2037689a057/ansi_off", "reason": "SELECT ceiling(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "ceiling#edc642c068e1/ansi_on", - "reason": "SELECT ceiling(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT" - }, - { - "id": "ceiling#edc642c068e1/ansi_off", - "reason": "SELECT ceiling(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT" - }, { "id": "ceiling#f4a8508a15c7/ansi_on", "reason": "SELECT ceiling(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/char_length.json b/tests/fixtures/analysis/registry-matrix/char_length.json index 8b3674002..a97efc487 100644 --- a/tests/fixtures/analysis/registry-matrix/char_length.json +++ b/tests/fixtures/analysis/registry-matrix/char_length.json @@ -24,14 +24,6 @@ "id": "char_length#51c55d351a74/ansi_off", "reason": "SELECT char_length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "char_length#5ae2fd4ad7df/ansi_on", - "reason": "SELECT char_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "char_length#5ae2fd4ad7df/ansi_off", - "reason": "SELECT char_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "char_length#f6d2d8a18a6b/ansi_on", "reason": "SELECT char_length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/character_length.json b/tests/fixtures/analysis/registry-matrix/character_length.json index e10da22fb..2a8d8733a 100644 --- a/tests/fixtures/analysis/registry-matrix/character_length.json +++ b/tests/fixtures/analysis/registry-matrix/character_length.json @@ -31,14 +31,6 @@ { "id": "character_length#86662ee970bb/ansi_off", "reason": "SELECT character_length(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "character_length#9ab7c3b48505/ansi_on", - "reason": "SELECT character_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "character_length#9ab7c3b48505/ansi_off", - "reason": "SELECT character_length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/coalesce.json b/tests/fixtures/analysis/registry-matrix/coalesce.json index 84c9d8037..6c9845093 100644 --- a/tests/fixtures/analysis/registry-matrix/coalesce.json +++ b/tests/fixtures/analysis/registry-matrix/coalesce.json @@ -24,14 +24,6 @@ "id": "coalesce#31842a9dbd4d/ansi_off", "reason": "SELECT coalesce(NULL, INTERVAL '1 02:03:04' DAY TO SECOND, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "coalesce#3297ad75dfb5/ansi_on", - "reason": "SELECT coalesce(array(1, 2), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "coalesce#3297ad75dfb5/ansi_off", - "reason": "SELECT coalesce(array(1, 2), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "coalesce#58920259386f/ansi_on", "reason": "SELECT coalesce(map('a', 1), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -64,14 +56,6 @@ "id": "coalesce#6b6547c1b6c0/ansi_off", "reason": "SELECT coalesce(INTERVAL '1 02:03:04' DAY TO SECOND, 1, NULL) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "coalesce#8b4e6c6ee9e8/ansi_on", - "reason": "SELECT coalesce(NULL, array(1, 2), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "coalesce#8b4e6c6ee9e8/ansi_off", - "reason": "SELECT coalesce(NULL, array(1, 2), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "coalesce#96e065bc5266/ansi_on", "reason": "SELECT coalesce(named_struct('a', 1, 'b', 'x'), 1, NULL) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -96,14 +80,6 @@ "id": "coalesce#ad0be0bee7ac/ansi_off", "reason": "SELECT coalesce(NULL, 1, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "coalesce#afa62deb2dc3/ansi_on", - "reason": "SELECT coalesce(NULL, 1, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "coalesce#afa62deb2dc3/ansi_off", - "reason": "SELECT coalesce(NULL, 1, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "coalesce#c5de409dc37c/ansi_on", "reason": "SELECT coalesce(NULL, 1, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/contains.json b/tests/fixtures/analysis/registry-matrix/contains.json index 3be7bdb8d..6a1cd8eba 100644 --- a/tests/fixtures/analysis/registry-matrix/contains.json +++ b/tests/fixtures/analysis/registry-matrix/contains.json @@ -32,14 +32,6 @@ "id": "contains#6c826c84c7a4/ansi_off", "reason": "SELECT contains(INTERVAL '1-2' YEAR TO MONTH, 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "contains#a2d830b27abd/ansi_on", - "reason": "SELECT contains('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "contains#a2d830b27abd/ansi_off", - "reason": "SELECT contains('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "contains#acc8127286a1/ansi_on", "reason": "SELECT contains('Spark SQL', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,6 @@ "id": "contains#acc8127286a1/ansi_off", "reason": "SELECT contains('Spark SQL', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "contains#c94bfd9f0f0a/ansi_on", - "reason": "SELECT contains(array(1, 2), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "contains#c94bfd9f0f0a/ansi_off", - "reason": "SELECT contains(array(1, 2), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "contains#d7f2b5dd724d/ansi_on", "reason": "SELECT contains('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/conv.json b/tests/fixtures/analysis/registry-matrix/conv.json index 7a225c22e..c8ed496ba 100644 --- a/tests/fixtures/analysis/registry-matrix/conv.json +++ b/tests/fixtures/analysis/registry-matrix/conv.json @@ -40,14 +40,6 @@ "id": "conv#7461c93e555c/ansi_off", "reason": "SELECT conv(INTERVAL '1 02:03:04' DAY TO SECOND, 2, 10) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "conv#7a657a811c87/ansi_on", - "reason": "SELECT conv(array(1, 2), 2, 10) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "conv#7a657a811c87/ansi_off", - "reason": "SELECT conv(array(1, 2), 2, 10) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "conv#81a1f2194627/ansi_on", "reason": "SELECT conv('100', INTERVAL '1-2' YEAR TO MONTH, 10) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -88,14 +80,6 @@ "id": "conv#94a8f88df66a/ansi_off", "reason": "SELECT conv('100', 2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "conv#99e8cdec0d93/ansi_on", - "reason": "SELECT conv('100', array(1, 2), 10) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "conv#99e8cdec0d93/ansi_off", - "reason": "SELECT conv('100', array(1, 2), 10) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "conv#bb384aabc1fa/ansi_on", "reason": "SELECT conv('100', 2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -111,14 +95,6 @@ { "id": "conv#c45bee861796/ansi_off", "reason": "SELECT conv(map('a', 1), 2, 10) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "conv#ec214d3068bf/ansi_on", - "reason": "SELECT conv('100', 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "conv#ec214d3068bf/ansi_off", - "reason": "SELECT conv('100', 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/convert_timezone.json b/tests/fixtures/analysis/registry-matrix/convert_timezone.json index 099400206..6edcaae65 100644 --- a/tests/fixtures/analysis/registry-matrix/convert_timezone.json +++ b/tests/fixtures/analysis/registry-matrix/convert_timezone.json @@ -16,14 +16,6 @@ "id": "convert_timezone#147a06c5b92b/ansi_off", "reason": "SELECT convert_timezone(INTERVAL '1-2' YEAR TO MONTH, timestamp_ntz'2021-12-05 15:00:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "convert_timezone#17ebeac38975/ansi_on", - "reason": "SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#17ebeac38975/ansi_off", - "reason": "SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "convert_timezone#1da32c16d231/ansi_on", "reason": "SELECT convert_timezone('Europe/Brussels', 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": "convert_timezone#1da32c16d231/ansi_off", "reason": "SELECT convert_timezone('Europe/Brussels', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "convert_timezone#1de7cd4cc6a8/ansi_on", - "reason": "SELECT convert_timezone(array(1, 2), timestamp_ntz'2021-12-05 15:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#1de7cd4cc6a8/ansi_off", - "reason": "SELECT convert_timezone(array(1, 2), timestamp_ntz'2021-12-05 15:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "convert_timezone#2661b7e18ccc/ansi_on", "reason": "SELECT convert_timezone(INTERVAL '1 02:03:04' DAY TO SECOND, 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -88,14 +72,6 @@ "id": "convert_timezone#4b75798678ba/ansi_off", "reason": "SELECT convert_timezone('Europe/Brussels', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "convert_timezone#51a54a73ab9d/ansi_on", - "reason": "SELECT convert_timezone('Europe/Brussels', array(1, 2), timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#51a54a73ab9d/ansi_off", - "reason": "SELECT convert_timezone('Europe/Brussels', array(1, 2), timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "convert_timezone#5a82d191b61f/ansi_on", "reason": "SELECT convert_timezone(map('a', 1), timestamp_ntz'2021-12-05 15:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -152,14 +128,6 @@ "id": "convert_timezone#b0dd48f6ba13/ansi_off", "reason": "SELECT convert_timezone('Europe/Brussels', INTERVAL '1-2' YEAR TO MONTH, timestamp_ntz'2021-12-06 00:00:00') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "convert_timezone#b3dc648c2fdf/ansi_on", - "reason": "SELECT convert_timezone('Europe/Brussels', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#b3dc648c2fdf/ansi_off", - "reason": "SELECT convert_timezone('Europe/Brussels', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "convert_timezone#cc1eb2d7ea80/ansi_on", "reason": "SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -184,14 +152,6 @@ "id": "convert_timezone#de6ad2d4213f/ansi_off", "reason": "SELECT convert_timezone(named_struct('a', 1, 'b', 'x'), timestamp_ntz'2021-12-05 15:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "convert_timezone#f585af0294f1/ansi_on", - "reason": "SELECT convert_timezone(array(1, 2), 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "convert_timezone#f585af0294f1/ansi_off", - "reason": "SELECT convert_timezone(array(1, 2), 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "convert_timezone#f9774a50969a/ansi_on", "reason": "SELECT convert_timezone('Europe/Brussels', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/cos.json b/tests/fixtures/analysis/registry-matrix/cos.json index 049070043..a9d4b4816 100644 --- a/tests/fixtures/analysis/registry-matrix/cos.json +++ b/tests/fixtures/analysis/registry-matrix/cos.json @@ -31,14 +31,6 @@ { "id": "cos#6e49e17c44c6/ansi_off", "reason": "SELECT cos(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "cos#d8a37c57177c/ansi_on", - "reason": "SELECT cos(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "cos#d8a37c57177c/ansi_off", - "reason": "SELECT cos(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/cosh.json b/tests/fixtures/analysis/registry-matrix/cosh.json index 556ceb171..7957691c2 100644 --- a/tests/fixtures/analysis/registry-matrix/cosh.json +++ b/tests/fixtures/analysis/registry-matrix/cosh.json @@ -8,14 +8,6 @@ "id": "cosh#19241e43181f/ansi_off", "reason": "SELECT cosh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "cosh#237a92894fe4/ansi_on", - "reason": "SELECT cosh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "cosh#237a92894fe4/ansi_off", - "reason": "SELECT cosh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "cosh#43b9893c0613/ansi_on", "reason": "SELECT cosh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/cot.json b/tests/fixtures/analysis/registry-matrix/cot.json index 3bf3bd89d..b651920c9 100644 --- a/tests/fixtures/analysis/registry-matrix/cot.json +++ b/tests/fixtures/analysis/registry-matrix/cot.json @@ -8,14 +8,6 @@ "id": "cot#8ce11c7a7b63/ansi_off", "reason": "SELECT cot(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "cot#c525cd60d93f/ansi_on", - "reason": "SELECT cot(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "cot#c525cd60d93f/ansi_off", - "reason": "SELECT cot(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "cot#d332d357b677/ansi_on", "reason": "SELECT cot(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/crc32.json b/tests/fixtures/analysis/registry-matrix/crc32.json index 97556977e..c490b62e4 100644 --- a/tests/fixtures/analysis/registry-matrix/crc32.json +++ b/tests/fixtures/analysis/registry-matrix/crc32.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "crc32#2651371c29d2/ansi_on", - "reason": "SELECT crc32(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "crc32#2651371c29d2/ansi_off", - "reason": "SELECT crc32(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "crc32#4f1001de936c/ansi_on", "reason": "SELECT crc32(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/csc.json b/tests/fixtures/analysis/registry-matrix/csc.json index 0a33357fd..e2e2ff923 100644 --- a/tests/fixtures/analysis/registry-matrix/csc.json +++ b/tests/fixtures/analysis/registry-matrix/csc.json @@ -16,14 +16,6 @@ "id": "csc#9a00661998eb/ansi_off", "reason": "SELECT csc(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "csc#adfe5d6693e0/ansi_on", - "reason": "SELECT csc(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "csc#adfe5d6693e0/ansi_off", - "reason": "SELECT csc(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "csc#d0426d85be78/ansi_on", "reason": "SELECT csc(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/date_add.json b/tests/fixtures/analysis/registry-matrix/date_add.json index 66479b9fe..2de12f305 100644 --- a/tests/fixtures/analysis/registry-matrix/date_add.json +++ b/tests/fixtures/analysis/registry-matrix/date_add.json @@ -32,14 +32,6 @@ "id": "date_add#a2161f5ef3fc/ansi_off", "reason": "SELECT date_add(INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_add#a8f6b473b026/ansi_on", - "reason": "SELECT date_add('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_add#a8f6b473b026/ansi_off", - "reason": "SELECT date_add('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_add#ba2bfcb95b8b/ansi_on", "reason": "SELECT date_add('2016-07-30', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +56,6 @@ "id": "date_add#f2dc2418fe02/ansi_off", "reason": "SELECT date_add(named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_add#f3fabb0301c9/ansi_on", - "reason": "SELECT date_add(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_add#f3fabb0301c9/ansi_off", - "reason": "SELECT date_add(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_add#fad633c93567/ansi_on", "reason": "SELECT date_add('2016-07-30', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/date_diff.json b/tests/fixtures/analysis/registry-matrix/date_diff.json index cc36a0a71..89fcb131e 100644 --- a/tests/fixtures/analysis/registry-matrix/date_diff.json +++ b/tests/fixtures/analysis/registry-matrix/date_diff.json @@ -8,14 +8,6 @@ "id": "date_diff#05942e933fcc/ansi_off", "reason": "SELECT date_diff(map('a', 1), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_diff#06d2c47693d1/ansi_on", - "reason": "SELECT date_diff(array(1, 2), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_diff#06d2c47693d1/ansi_off", - "reason": "SELECT date_diff(array(1, 2), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_diff#13970b9a8111/ansi_on", "reason": "SELECT date_diff(INTERVAL '1-2' YEAR TO MONTH, '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -40,14 +32,6 @@ "id": "date_diff#551ef3d9f510/ansi_off", "reason": "SELECT date_diff('2009-07-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_diff#59223d845876/ansi_on", - "reason": "SELECT date_diff('2009-07-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_diff#59223d845876/ansi_off", - "reason": "SELECT date_diff('2009-07-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_diff#7612d4b942ab/ansi_on", "reason": "SELECT date_diff('2009-07-31', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/date_part.json b/tests/fixtures/analysis/registry-matrix/date_part.json index aec55560d..6a84afdda 100644 --- a/tests/fixtures/analysis/registry-matrix/date_part.json +++ b/tests/fixtures/analysis/registry-matrix/date_part.json @@ -48,14 +48,6 @@ "id": "date_part#636c907f859b/ansi_off", "reason": "SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "date_part#7bb6e029aba1/ansi_on", - "reason": "SELECT date_part('YEAR', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_part#7bb6e029aba1/ansi_off", - "reason": "SELECT date_part('YEAR', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_part#a7d2bff3fe87/ansi_on", "reason": "SELECT date_part('days', interval 5 days 3 hours 7 minutes) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -74,11 +66,11 @@ }, { "id": "date_part#aee6337cfd66/ansi_on", - "reason": "SELECT date_part(array(1, 2), TIMESTAMP '2019-08-12 01:00:00.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT" + "reason": "SELECT date_part(array(1, 2), TIMESTAMP '2019-08-12 01:00:00.123456') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has NON_FOLDABLE_ARGUMENT" }, { "id": "date_part#aee6337cfd66/ansi_off", - "reason": "SELECT date_part(array(1, 2), TIMESTAMP '2019-08-12 01:00:00.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT" + "reason": "SELECT date_part(array(1, 2), TIMESTAMP '2019-08-12 01:00:00.123456') | DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE where Spark has NON_FOLDABLE_ARGUMENT" }, { "id": "date_part#b27dc92b308a/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/date_sub.json b/tests/fixtures/analysis/registry-matrix/date_sub.json index c91c36d5d..5d6110369 100644 --- a/tests/fixtures/analysis/registry-matrix/date_sub.json +++ b/tests/fixtures/analysis/registry-matrix/date_sub.json @@ -24,14 +24,6 @@ "id": "date_sub#8fdbd3642b64/ansi_off", "reason": "SELECT date_sub(named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_sub#a24ef0a9b5b8/ansi_on", - "reason": "SELECT date_sub(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_sub#a24ef0a9b5b8/ansi_off", - "reason": "SELECT date_sub(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_sub#adae19b649ad/ansi_on", "reason": "SELECT date_sub(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,6 @@ "id": "date_sub#b39d32775713/ansi_off", "reason": "SELECT date_sub(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_sub#c2416e1a06e9/ansi_on", - "reason": "SELECT date_sub('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_sub#c2416e1a06e9/ansi_off", - "reason": "SELECT date_sub('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_sub#c296eaac697f/ansi_on", "reason": "SELECT date_sub('2016-07-30', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/date_trunc.json b/tests/fixtures/analysis/registry-matrix/date_trunc.json index a59f1f488..765cc283b 100644 --- a/tests/fixtures/analysis/registry-matrix/date_trunc.json +++ b/tests/fixtures/analysis/registry-matrix/date_trunc.json @@ -24,14 +24,6 @@ "id": "date_trunc#732475623b0f/ansi_off", "reason": "SELECT date_trunc('YEAR', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_trunc#939c9dd369ab/ansi_on", - "reason": "SELECT date_trunc(array(1, 2), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_trunc#939c9dd369ab/ansi_off", - "reason": "SELECT date_trunc(array(1, 2), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_trunc#ab8944d5b81e/ansi_on", "reason": "SELECT date_trunc(map('a', 1), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -40,14 +32,6 @@ "id": "date_trunc#ab8944d5b81e/ansi_off", "reason": "SELECT date_trunc(map('a', 1), '2015-03-05T09:32:05.359') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "date_trunc#b60f1d3d4024/ansi_on", - "reason": "SELECT date_trunc('YEAR', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "date_trunc#b60f1d3d4024/ansi_off", - "reason": "SELECT date_trunc('YEAR', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "date_trunc#bbab69ebe047/ansi_on", "reason": "SELECT date_trunc(INTERVAL '1 02:03:04' DAY TO SECOND, '2015-03-05T09:32:05.359') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/dateadd.json b/tests/fixtures/analysis/registry-matrix/dateadd.json index df3e78ed3..5a0e5f9c8 100644 --- a/tests/fixtures/analysis/registry-matrix/dateadd.json +++ b/tests/fixtures/analysis/registry-matrix/dateadd.json @@ -8,14 +8,6 @@ "id": "dateadd#09354e653fe5/ansi_off", "reason": "SELECT dateadd('2016-07-30', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "dateadd#1db53f156b77/ansi_on", - "reason": "SELECT dateadd('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dateadd#1db53f156b77/ansi_off", - "reason": "SELECT dateadd('2016-07-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "dateadd#207a6a5ed88a/ansi_on", "reason": "SELECT dateadd(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -24,14 +16,6 @@ "id": "dateadd#207a6a5ed88a/ansi_off", "reason": "SELECT dateadd(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "dateadd#54c3fbb83814/ansi_on", - "reason": "SELECT dateadd(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dateadd#54c3fbb83814/ansi_off", - "reason": "SELECT dateadd(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "dateadd#63408c53af98/ansi_on", "reason": "SELECT dateadd(INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/datediff.json b/tests/fixtures/analysis/registry-matrix/datediff.json index 9a053b465..49f30c6be 100644 --- a/tests/fixtures/analysis/registry-matrix/datediff.json +++ b/tests/fixtures/analysis/registry-matrix/datediff.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "datediff#18d30bab86bf/ansi_on", - "reason": "SELECT datediff(array(1, 2), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "datediff#18d30bab86bf/ansi_off", - "reason": "SELECT datediff(array(1, 2), '2009-07-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "datediff#1ada08a843e8/ansi_on", "reason": "SELECT datediff('2009-07-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +56,6 @@ "id": "datediff#9191f9843b3d/ansi_off", "reason": "SELECT datediff(INTERVAL '1 02:03:04' DAY TO SECOND, '2009-07-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "datediff#95d5a3cc05e6/ansi_on", - "reason": "SELECT datediff('2009-07-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "datediff#95d5a3cc05e6/ansi_off", - "reason": "SELECT datediff('2009-07-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "datediff#fe385609c0d8/ansi_on", "reason": "SELECT datediff('2009-07-31', 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/day.json b/tests/fixtures/analysis/registry-matrix/day.json index 74e6d3a61..86c906c80 100644 --- a/tests/fixtures/analysis/registry-matrix/day.json +++ b/tests/fixtures/analysis/registry-matrix/day.json @@ -8,14 +8,6 @@ "id": "day#281e66e4531b/ansi_off", "reason": "SELECT day(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "day#6ec736886dac/ansi_on", - "reason": "SELECT day(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "day#6ec736886dac/ansi_off", - "reason": "SELECT day(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "day#c5006e6a3413/ansi_on", "reason": "SELECT day(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/dayname.json b/tests/fixtures/analysis/registry-matrix/dayname.json index 0bfa0d35c..6c062c9a1 100644 --- a/tests/fixtures/analysis/registry-matrix/dayname.json +++ b/tests/fixtures/analysis/registry-matrix/dayname.json @@ -32,14 +32,6 @@ "id": "dayname#cd6ab24d7543/ansi_off", "reason": "SELECT dayname(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "dayname#d33c54efcf10/ansi_on", - "reason": "SELECT dayname(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dayname#d33c54efcf10/ansi_off", - "reason": "SELECT dayname(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "dayname#e01582a5b91e/ansi_on", "reason": "SELECT dayname(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/dayofmonth.json b/tests/fixtures/analysis/registry-matrix/dayofmonth.json index 889196588..c86edf1da 100644 --- a/tests/fixtures/analysis/registry-matrix/dayofmonth.json +++ b/tests/fixtures/analysis/registry-matrix/dayofmonth.json @@ -8,14 +8,6 @@ "id": "dayofmonth#0296012a73bf/ansi_off", "reason": "SELECT dayofmonth(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "dayofmonth#039eeb4f3b46/ansi_on", - "reason": "SELECT dayofmonth(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dayofmonth#039eeb4f3b46/ansi_off", - "reason": "SELECT dayofmonth(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "dayofmonth#63cbd5ac0445/ansi_on", "reason": "SELECT dayofmonth(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/dayofweek.json b/tests/fixtures/analysis/registry-matrix/dayofweek.json index e91adbb75..dedba9d5e 100644 --- a/tests/fixtures/analysis/registry-matrix/dayofweek.json +++ b/tests/fixtures/analysis/registry-matrix/dayofweek.json @@ -31,14 +31,6 @@ { "id": "dayofweek#b213f42da8ee/ansi_off", "reason": "SELECT dayofweek(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dayofweek#cb4a7b0f9f60/ansi_on", - "reason": "SELECT dayofweek(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dayofweek#cb4a7b0f9f60/ansi_off", - "reason": "SELECT dayofweek(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/dayofyear.json b/tests/fixtures/analysis/registry-matrix/dayofyear.json index 239018053..c54822749 100644 --- a/tests/fixtures/analysis/registry-matrix/dayofyear.json +++ b/tests/fixtures/analysis/registry-matrix/dayofyear.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "dayofyear#6b1828e51769/ansi_on", - "reason": "SELECT dayofyear(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "dayofyear#6b1828e51769/ansi_off", - "reason": "SELECT dayofyear(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "dayofyear#8545d9aa0c51/ansi_on", "reason": "SELECT dayofyear(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/degrees.json b/tests/fixtures/analysis/registry-matrix/degrees.json index 9d448603d..cffae1104 100644 --- a/tests/fixtures/analysis/registry-matrix/degrees.json +++ b/tests/fixtures/analysis/registry-matrix/degrees.json @@ -16,14 +16,6 @@ "id": "degrees#9a381aac8d04/ansi_off", "reason": "SELECT degrees(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "degrees#a6a490bd9aef/ansi_on", - "reason": "SELECT degrees(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "degrees#a6a490bd9aef/ansi_off", - "reason": "SELECT degrees(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "degrees#baea01745120/ansi_on", "reason": "SELECT degrees(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/endswith.json b/tests/fixtures/analysis/registry-matrix/endswith.json index 493e63be8..defca848d 100644 --- a/tests/fixtures/analysis/registry-matrix/endswith.json +++ b/tests/fixtures/analysis/registry-matrix/endswith.json @@ -48,14 +48,6 @@ "id": "endswith#7fc3b35cb0fa/ansi_off", "reason": "SELECT endswith(INTERVAL '1-2' YEAR TO MONTH, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "endswith#9d22842205a0/ansi_on", - "reason": "SELECT endswith(array(1, 2), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "endswith#9d22842205a0/ansi_off", - "reason": "SELECT endswith(array(1, 2), 'SQL') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "endswith#b18796f06dfa/ansi_on", "reason": "SELECT endswith('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -64,14 +56,6 @@ "id": "endswith#b18796f06dfa/ansi_off", "reason": "SELECT endswith('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "endswith#db6f4211cf83/ansi_on", - "reason": "SELECT endswith('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "endswith#db6f4211cf83/ansi_off", - "reason": "SELECT endswith('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "endswith#dd88f7cef81d/ansi_on", "reason": "SELECT endswith(INTERVAL '1 02:03:04' DAY TO SECOND, 'SQL') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/equal_null.json b/tests/fixtures/analysis/registry-matrix/equal_null.json index c3639d497..a84202ce9 100644 --- a/tests/fixtures/analysis/registry-matrix/equal_null.json +++ b/tests/fixtures/analysis/registry-matrix/equal_null.json @@ -4,14 +4,6 @@ "id": "equal_null#0355330fa7f3/ansi_off", "reason": "SELECT equal_null(3, true) | DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "equal_null#151a5c0cbdc9/ansi_on", - "reason": "SELECT equal_null(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "equal_null#151a5c0cbdc9/ansi_off", - "reason": "SELECT equal_null(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "equal_null#2992d8a79db7/ansi_on", "reason": "SELECT equal_null(3, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" @@ -108,14 +100,6 @@ "id": "equal_null#dbc27bba4cc8/ansi_off", "reason": "SELECT equal_null(3, 'abc') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "id": "equal_null#dd257456f4cb/ansi_on", - "reason": "SELECT equal_null(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "equal_null#dd257456f4cb/ansi_off", - "reason": "SELECT equal_null(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "equal_null#e2ccee8023d2/ansi_off", "reason": "SELECT equal_null(3, '1') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" diff --git a/tests/fixtures/analysis/registry-matrix/exists.json b/tests/fixtures/analysis/registry-matrix/exists.json new file mode 100644 index 000000000..b4befa835 --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/exists.json @@ -0,0 +1,86 @@ +{ + "entries": [ + { + "id": "exists#2555a2780a5a/ansi_on", + "reason": "SELECT exists(array(1, null, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "exists#2555a2780a5a/ansi_off", + "reason": "SELECT exists(array(1, null, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "exists#48d045dea176/ansi_on", + "reason": "SELECT exists(CAST(array() AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "exists#48d045dea176/ansi_off", + "reason": "SELECT exists(CAST(array() AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "exists#558cbae87dba/ansi_on", + "reason": "SELECT exists(array(1, 2, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "exists#558cbae87dba/ansi_off", + "reason": "SELECT exists(array(1, 2, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "exists#6a6847e8ef3b/ansi_on", + "reason": "SELECT exists(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "exists#6a6847e8ef3b/ansi_off", + "reason": "SELECT exists(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "exists#6e826ed77c7c/ansi_on", + "reason": "SELECT exists(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "exists#6e826ed77c7c/ansi_off", + "reason": "SELECT exists(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "exists#8f3eff5b5424/ansi_on", + "reason": "SELECT exists(array(1, 2, 3), x -> x % 2 == 10) | boolean not null where Spark has boolean" + }, + { + "id": "exists#8f3eff5b5424/ansi_off", + "reason": "SELECT exists(array(1, 2, 3), x -> x % 2 == 10) | boolean not null where Spark has boolean" + }, + { + "id": "exists#b57f088884a3/ansi_on", + "reason": "SELECT exists(array(1, 2), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "exists#b57f088884a3/ansi_off", + "reason": "SELECT exists(array(1, 2), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "exists#ba182479db25/ansi_on", + "reason": "SELECT exists(CAST(array(NULL) AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "exists#ba182479db25/ansi_off", + "reason": "SELECT exists(CAST(array(NULL) AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "exists#da2bc52421fa/ansi_on", + "reason": "SELECT exists(map('a', 1), x -> x % 2 == 0) | parse: PARSE_SYNTAX_ERROR where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "exists#da2bc52421fa/ansi_off", + "reason": "SELECT exists(map('a', 1), x -> x % 2 == 0) | parse: PARSE_SYNTAX_ERROR where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "exists#f70d6106d58b/ansi_on", + "reason": "SELECT exists(named_struct('a', 1, 'b', 'x'), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "exists#f70d6106d58b/ansi_off", + "reason": "SELECT exists(named_struct('a', 1, 'b', 'x'), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + } + ], + "format_version": 1, + "function": "exists" +} diff --git a/tests/fixtures/analysis/registry-matrix/exp.json b/tests/fixtures/analysis/registry-matrix/exp.json index 3df99ed6a..5b940a556 100644 --- a/tests/fixtures/analysis/registry-matrix/exp.json +++ b/tests/fixtures/analysis/registry-matrix/exp.json @@ -24,14 +24,6 @@ "id": "exp#c0495deda736/ansi_off", "reason": "SELECT exp(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "exp#eec810ac174b/ansi_on", - "reason": "SELECT exp(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "exp#eec810ac174b/ansi_off", - "reason": "SELECT exp(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "exp#f67051cd986a/ansi_on", "reason": "SELECT exp(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/expm1.json b/tests/fixtures/analysis/registry-matrix/expm1.json index 4378b0dde..497d2f130 100644 --- a/tests/fixtures/analysis/registry-matrix/expm1.json +++ b/tests/fixtures/analysis/registry-matrix/expm1.json @@ -8,14 +8,6 @@ "id": "expm1#1e50e604d85a/ansi_off", "reason": "SELECT expm1(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "expm1#235cf212eb44/ansi_on", - "reason": "SELECT expm1(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "expm1#235cf212eb44/ansi_off", - "reason": "SELECT expm1(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "expm1#34c7be4db61b/ansi_on", "reason": "SELECT expm1(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/filter.json b/tests/fixtures/analysis/registry-matrix/filter.json new file mode 100644 index 000000000..18180ebbb --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/filter.json @@ -0,0 +1,46 @@ +{ + "entries": [ + { + "id": "filter#5cb73ec32bff/ansi_on", + "reason": "SELECT filter(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "filter#5cb73ec32bff/ansi_off", + "reason": "SELECT filter(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "filter#81fb6a4362e6/ansi_on", + "reason": "SELECT filter(named_struct('a', 1, 'b', 'x'), x -> x % 2 == 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "filter#81fb6a4362e6/ansi_off", + "reason": "SELECT filter(named_struct('a', 1, 'b', 'x'), x -> x % 2 == 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "filter#87053e478033/ansi_on", + "reason": "SELECT filter(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "filter#87053e478033/ansi_off", + "reason": "SELECT filter(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "filter#b772a52335ae/ansi_on", + "reason": "SELECT filter(map('a', 1), x -> x % 2 == 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "filter#b772a52335ae/ansi_off", + "reason": "SELECT filter(map('a', 1), x -> x % 2 == 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "filter#cc869a817020/ansi_on", + "reason": "SELECT filter(array(0, 2, 3), (x, i) -> x > i) | INVALID_LAMBDA_FUNCTION_CALL.NUM_ARGS_MISMATCH" + }, + { + "id": "filter#cc869a817020/ansi_off", + "reason": "SELECT filter(array(0, 2, 3), (x, i) -> x > i) | INVALID_LAMBDA_FUNCTION_CALL.NUM_ARGS_MISMATCH" + } + ], + "format_version": 1, + "function": "filter" +} diff --git a/tests/fixtures/analysis/registry-matrix/first.json b/tests/fixtures/analysis/registry-matrix/first.json index 4603657b1..4ff48b70a 100644 --- a/tests/fixtures/analysis/registry-matrix/first.json +++ b/tests/fixtures/analysis/registry-matrix/first.json @@ -31,14 +31,6 @@ { "id": "first#64070551472e/ansi_off", "reason": "SELECT first(col, named_struct('a', 1, 'b', 'x')) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "first#7142e82e71a1/ansi_on", - "reason": "SELECT first(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "first#7142e82e71a1/ansi_off", - "reason": "SELECT first(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/first_value.json b/tests/fixtures/analysis/registry-matrix/first_value.json index f6feaae8a..2d5e4e82f 100644 --- a/tests/fixtures/analysis/registry-matrix/first_value.json +++ b/tests/fixtures/analysis/registry-matrix/first_value.json @@ -8,14 +8,6 @@ "id": "first_value#09990f542e34/ansi_off", "reason": "SELECT first_value(col, named_struct('a', 1, 'b', 'x')) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has _LEGACY_ERROR_TEMP_1210" }, - { - "id": "first_value#0e35783b59e8/ansi_on", - "reason": "SELECT first_value(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "first_value#0e35783b59e8/ansi_off", - "reason": "SELECT first_value(col, array(1, 2)) FROM VALUES (NULL), (5), (20) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" - }, { "id": "first_value#5f9c5c85c0ca/ansi_on", "reason": "SELECT first_value(col, INTERVAL '1 02:03:04' DAY TO SECOND) FROM VALUES (NULL), (5), (20) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210" diff --git a/tests/fixtures/analysis/registry-matrix/floor.json b/tests/fixtures/analysis/registry-matrix/floor.json index a2fe09dde..7eb254696 100644 --- a/tests/fixtures/analysis/registry-matrix/floor.json +++ b/tests/fixtures/analysis/registry-matrix/floor.json @@ -56,14 +56,6 @@ "id": "floor#716ba7127f26/ansi_off", "reason": "SELECT floor(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "floor#730d8fe10a5a/ansi_on", - "reason": "SELECT floor(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT" - }, - { - "id": "floor#730d8fe10a5a/ansi_off", - "reason": "SELECT floor(3.1411, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has NON_FOLDABLE_ARGUMENT" - }, { "id": "floor#942126e7d9cc/ansi_on", "reason": "SELECT floor(named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -88,14 +80,6 @@ "id": "floor#a8fb09ca0432/ansi_off", "reason": "SELECT floor(INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "floor#c55c5c7689d7/ansi_on", - "reason": "SELECT floor(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "floor#c55c5c7689d7/ansi_off", - "reason": "SELECT floor(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "floor#e063de715f94/ansi_on", "reason": "SELECT floor(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -104,14 +88,6 @@ "id": "floor#e063de715f94/ansi_off", "reason": "SELECT floor(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "floor#eafebbc04618/ansi_on", - "reason": "SELECT floor(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "floor#eafebbc04618/ansi_off", - "reason": "SELECT floor(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "floor#f7b36fd3e154/ansi_on", "reason": "SELECT floor(map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/forall.json b/tests/fixtures/analysis/registry-matrix/forall.json new file mode 100644 index 000000000..040a0ef9d --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/forall.json @@ -0,0 +1,94 @@ +{ + "entries": [ + { + "id": "forall#0c7952ae1a01/ansi_on", + "reason": "SELECT forall(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "forall#0c7952ae1a01/ansi_off", + "reason": "SELECT forall(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "forall#3a97060c1889/ansi_on", + "reason": "SELECT forall(CAST(array(NULL) AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#3a97060c1889/ansi_off", + "reason": "SELECT forall(CAST(array(NULL) AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#4990494cff81/ansi_on", + "reason": "SELECT forall(array(1, null, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#4990494cff81/ansi_off", + "reason": "SELECT forall(array(1, null, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#5efff6957542/ansi_on", + "reason": "SELECT forall(array(1, 2), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#5efff6957542/ansi_off", + "reason": "SELECT forall(array(1, 2), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#7781d8d40b2b/ansi_on", + "reason": "SELECT forall(map('a', 1), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "forall#7781d8d40b2b/ansi_off", + "reason": "SELECT forall(map('a', 1), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "forall#9c7a1e75739a/ansi_on", + "reason": "SELECT forall(CAST(array() AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#9c7a1e75739a/ansi_off", + "reason": "SELECT forall(CAST(array() AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#a88594001a66/ansi_on", + "reason": "SELECT forall(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "forall#a88594001a66/ansi_off", + "reason": "SELECT forall(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "forall#abbf8a9f2d21/ansi_on", + "reason": "SELECT forall(array(2, null, 8), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#abbf8a9f2d21/ansi_off", + "reason": "SELECT forall(array(2, null, 8), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#b289e7a29570/ansi_on", + "reason": "SELECT forall(array(2, 4, 8), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#b289e7a29570/ansi_off", + "reason": "SELECT forall(array(2, 4, 8), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#b9b4aee34cc6/ansi_on", + "reason": "SELECT forall(named_struct('a', 1, 'b', 'x'), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "forall#b9b4aee34cc6/ansi_off", + "reason": "SELECT forall(named_struct('a', 1, 'b', 'x'), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "forall#c2a0228edaea/ansi_on", + "reason": "SELECT forall(array(1, 2, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" + }, + { + "id": "forall#c2a0228edaea/ansi_off", + "reason": "SELECT forall(array(1, 2, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" + } + ], + "format_version": 1, + "function": "forall" +} diff --git a/tests/fixtures/analysis/registry-matrix/format_number.json b/tests/fixtures/analysis/registry-matrix/format_number.json index 7beb56179..fd08d525b 100644 --- a/tests/fixtures/analysis/registry-matrix/format_number.json +++ b/tests/fixtures/analysis/registry-matrix/format_number.json @@ -40,14 +40,6 @@ "id": "format_number#7991368b7a6a/ansi_off", "reason": "SELECT format_number(named_struct('a', 1, 'b', 'x'), 4) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "format_number#a01c09659bab/ansi_on", - "reason": "SELECT format_number(12332.123456, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "format_number#a01c09659bab/ansi_off", - "reason": "SELECT format_number(12332.123456, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "format_number#ba6583b472bc/ansi_on", "reason": "SELECT format_number(12332.123456, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,6 @@ "id": "format_number#ba6583b472bc/ansi_off", "reason": "SELECT format_number(12332.123456, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "format_number#de8e4198e9f4/ansi_on", - "reason": "SELECT format_number(array(1, 2), 4) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "format_number#de8e4198e9f4/ansi_off", - "reason": "SELECT format_number(array(1, 2), 4) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "format_number#f2eb3f7a47db/ansi_on", "reason": "SELECT format_number(INTERVAL '1 02:03:04' DAY TO SECOND, 4) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json b/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json index 768cc3769..0c793dd94 100644 --- a/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json +++ b/tests/fixtures/analysis/registry-matrix/from_utc_timestamp.json @@ -40,14 +40,6 @@ "id": "from_utc_timestamp#70953829339b/ansi_off", "reason": "SELECT from_utc_timestamp('2016-08-31', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "from_utc_timestamp#7a2f639bdf28/ansi_on", - "reason": "SELECT from_utc_timestamp(array(1, 2), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "from_utc_timestamp#7a2f639bdf28/ansi_off", - "reason": "SELECT from_utc_timestamp(array(1, 2), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "from_utc_timestamp#83b5c806c510/ansi_on", "reason": "SELECT from_utc_timestamp('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,6 @@ "id": "from_utc_timestamp#83b5c806c510/ansi_off", "reason": "SELECT from_utc_timestamp('2016-08-31', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "from_utc_timestamp#94ac3581dfd4/ansi_on", - "reason": "SELECT from_utc_timestamp('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "from_utc_timestamp#94ac3581dfd4/ansi_off", - "reason": "SELECT from_utc_timestamp('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "from_utc_timestamp#c51e736ccf25/ansi_on", "reason": "SELECT from_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/getbit.json b/tests/fixtures/analysis/registry-matrix/getbit.json index aa8ffb768..dc60ba45e 100644 --- a/tests/fixtures/analysis/registry-matrix/getbit.json +++ b/tests/fixtures/analysis/registry-matrix/getbit.json @@ -32,14 +32,6 @@ "id": "getbit#62e5bcef8380/ansi_off", "reason": "SELECT getbit(11, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "getbit#699ba6576802/ansi_on", - "reason": "SELECT getbit(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "getbit#699ba6576802/ansi_off", - "reason": "SELECT getbit(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "getbit#7579ff069735/ansi_on", "reason": "SELECT getbit(INTERVAL '1 02:03:04' DAY TO SECOND, 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,6 @@ "id": "getbit#915c2a9d1452/ansi_off", "reason": "SELECT getbit(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "getbit#9419dda3fafc/ansi_on", - "reason": "SELECT getbit(11, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "getbit#9419dda3fafc/ansi_off", - "reason": "SELECT getbit(11, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "getbit#9a65369e9227/ansi_on", "reason": "SELECT getbit(11, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/greatest.json b/tests/fixtures/analysis/registry-matrix/greatest.json index 73d57b7ac..e8ba28fbe 100644 --- a/tests/fixtures/analysis/registry-matrix/greatest.json +++ b/tests/fixtures/analysis/registry-matrix/greatest.json @@ -16,14 +16,6 @@ "id": "greatest#096852702824/ansi_off", "reason": "SELECT greatest(INTERVAL '1 02:03:04' DAY TO SECOND, 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "greatest#13c6afe65002/ansi_on", - "reason": "SELECT greatest(array(1, 2), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "greatest#13c6afe65002/ansi_off", - "reason": "SELECT greatest(array(1, 2), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "greatest#153b990a709e/ansi_on", "reason": "SELECT greatest(INTERVAL '1-2' YEAR TO MONTH, 9, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -40,14 +32,6 @@ "id": "greatest#27d19c21be34/ansi_off", "reason": "SELECT greatest(10, 9, 2, 4, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "greatest#3ae8320b93cc/ansi_on", - "reason": "SELECT greatest(10, array(1, 2), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "greatest#3ae8320b93cc/ansi_off", - "reason": "SELECT greatest(10, array(1, 2), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "greatest#3b87446f2696/ansi_on", "reason": "SELECT greatest(10, 9, 2, INTERVAL '1-2' YEAR TO MONTH, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -96,14 +80,6 @@ "id": "greatest#7421d8bc18eb/ansi_off", "reason": "SELECT greatest(10, 9, named_struct('a', 1, 'b', 'x'), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "greatest#80f86bb7e057/ansi_on", - "reason": "SELECT greatest(10, 9, 2, 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "greatest#80f86bb7e057/ansi_off", - "reason": "SELECT greatest(10, 9, 2, 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "greatest#824668970bd6/ansi_on", "reason": "SELECT greatest(map('a', 1), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -120,14 +96,6 @@ "id": "greatest#84abe3fe1684/ansi_off", "reason": "SELECT greatest(10, 9, 2, named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "greatest#91ff7769043f/ansi_on", - "reason": "SELECT greatest(10, 9, 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "greatest#91ff7769043f/ansi_off", - "reason": "SELECT greatest(10, 9, 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "greatest#98f8bb73a148/ansi_on", "reason": "SELECT greatest(10, INTERVAL '1 02:03:04' DAY TO SECOND, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -160,14 +128,6 @@ "id": "greatest#b2adb244d3ee/ansi_off", "reason": "SELECT greatest(10, 9, 2, map('a', 1), 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "greatest#b51e4d0651cf/ansi_on", - "reason": "SELECT greatest(10, 9, array(1, 2), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "greatest#b51e4d0651cf/ansi_off", - "reason": "SELECT greatest(10, 9, array(1, 2), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "greatest#b9d968efd344/ansi_on", "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" diff --git a/tests/fixtures/analysis/registry-matrix/hash.json b/tests/fixtures/analysis/registry-matrix/hash.json index 5bb40c20c..50d6aff1b 100644 --- a/tests/fixtures/analysis/registry-matrix/hash.json +++ b/tests/fixtures/analysis/registry-matrix/hash.json @@ -1,69 +1,5 @@ { "entries": [ - { - "id": "hash#050efa42b0aa/ansi_on", - "reason": "SELECT hash(1, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#050efa42b0aa/ansi_off", - "reason": "SELECT hash(1, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#06b7e5d007f1/ansi_on", - "reason": "SELECT hash('Spark', array(123), CAST(1 AS TINYINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#06b7e5d007f1/ansi_off", - "reason": "SELECT hash('Spark', array(123), CAST(1 AS TINYINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#07ecd1ec737e/ansi_on", - "reason": "SELECT hash('Ä€日本語😀é', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#07ecd1ec737e/ansi_off", - "reason": "SELECT hash('Ä€日本語😀é', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#10a009d846e4/ansi_on", - "reason": "SELECT hash(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#10a009d846e4/ansi_off", - "reason": "SELECT hash(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#11dc78602219/ansi_on", - "reason": "SELECT hash('Spark', array(123), CAST(1 AS SMALLINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#11dc78602219/ansi_off", - "reason": "SELECT hash('Spark', array(123), CAST(1 AS SMALLINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#16de041f73d5/ansi_on", - "reason": "SELECT hash('Spark', CAST(array() AS array), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#16de041f73d5/ansi_off", - "reason": "SELECT hash('Spark', CAST(array() AS array), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#17ae377c1c3e/ansi_on", - "reason": "SELECT hash('Spark', array(123), 'abc') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#17ae377c1c3e/ansi_off", - "reason": "SELECT hash('Spark', array(123), 'abc') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#183f10259830/ansi_on", - "reason": "SELECT hash('Spark', array(123), 1L) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#183f10259830/ansi_off", - "reason": "SELECT hash('Spark', array(123), 1L) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "hash#1d95ab5f2f7f/ansi_on", "reason": "SELECT hash(INTERVAL '1 02:03:04' DAY TO SECOND, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -72,30 +8,6 @@ "id": "hash#1d95ab5f2f7f/ansi_off", "reason": "SELECT hash(INTERVAL '1 02:03:04' DAY TO SECOND, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "hash#20ac6b855c3f/ansi_on", - "reason": "SELECT hash('Spark', array(123), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#20ac6b855c3f/ansi_off", - "reason": "SELECT hash('Spark', array(123), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#239f9a29c6da/ansi_on", - "reason": "SELECT hash(NULL, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#239f9a29c6da/ansi_off", - "reason": "SELECT hash(NULL, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#243662e44338/ansi_on", - "reason": "SELECT hash(DATE'2024-02-29', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#243662e44338/ansi_off", - "reason": "SELECT hash(DATE'2024-02-29', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "hash#272caba7a158/ansi_on", "reason": "SELECT hash(named_struct('a', 1, 'b', 'x'), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" @@ -104,61 +16,13 @@ "id": "hash#272caba7a158/ansi_off", "reason": "SELECT hash(named_struct('a', 1, 'b', 'x'), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" }, - { - "id": "hash#31388d31f097/ansi_on", - "reason": "SELECT hash('Spark', array(123), X'01') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#31388d31f097/ansi_off", - "reason": "SELECT hash('Spark', array(123), X'01') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#36486ceb689e/ansi_on", - "reason": "SELECT hash('abc', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#36486ceb689e/ansi_off", - "reason": "SELECT hash('abc', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#40b05b7dd3b8/ansi_on", - "reason": "SELECT hash(CAST(1.5 AS FLOAT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#40b05b7dd3b8/ansi_off", - "reason": "SELECT hash(CAST(1.5 AS FLOAT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#4662df6e4cfe/ansi_on", - "reason": "SELECT hash('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#4662df6e4cfe/ansi_off", - "reason": "SELECT hash('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#4a599039809c/ansi_on", - "reason": "SELECT hash(CAST(NULL AS string), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#4a599039809c/ansi_off", - "reason": "SELECT hash(CAST(NULL AS string), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#4bb2495feeff/ansi_on", - "reason": "SELECT hash('Spark', array(123), CAST(-2147483648 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#4bb2495feeff/ansi_off", - "reason": "SELECT hash('Spark', array(123), CAST(-2147483648 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "hash#4d1d1a99deac/ansi_on", - "reason": "SELECT hash('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + "reason": "SELECT hash('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" }, { "id": "hash#4d1d1a99deac/ansi_off", - "reason": "SELECT hash('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + "reason": "SELECT hash('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" }, { "id": "hash#51a176d3611e/ansi_on", @@ -168,54 +32,6 @@ "id": "hash#51a176d3611e/ansi_off", "reason": "SELECT hash('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, - { - "id": "hash#5556de897838/ansi_on", - "reason": "SELECT hash('1', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#5556de897838/ansi_off", - "reason": "SELECT hash('1', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#56ac03b0a2dd/ansi_on", - "reason": "SELECT hash('Spark', array(123), DATE'2024-02-29') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#56ac03b0a2dd/ansi_off", - "reason": "SELECT hash('Spark', array(123), DATE'2024-02-29') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#57961fe78970/ansi_on", - "reason": "SELECT hash('Spark', array(123), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#57961fe78970/ansi_off", - "reason": "SELECT hash('Spark', array(123), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#58278334416c/ansi_on", - "reason": "SELECT hash('Spark', array(123), 1.5D) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#58278334416c/ansi_off", - "reason": "SELECT hash('Spark', array(123), 1.5D) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#5a4364ed7c74/ansi_on", - "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS FLOAT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#5a4364ed7c74/ansi_off", - "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS FLOAT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#5a92f4b086c0/ansi_on", - "reason": "SELECT hash(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#5a92f4b086c0/ansi_off", - "reason": "SELECT hash(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "hash#68ccd0f7afcd/ansi_on", "reason": "SELECT hash(map('a', 1), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" @@ -232,14 +48,6 @@ "id": "hash#7d1796847464/ansi_off", "reason": "SELECT hash('Spark', array(123), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "hash#80833cec99fa/ansi_on", - "reason": "SELECT hash(X'01', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#80833cec99fa/ansi_off", - "reason": "SELECT hash(X'01', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "hash#838d1e1f3358/ansi_on", "reason": "SELECT hash('Spark', INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -248,102 +56,6 @@ "id": "hash#838d1e1f3358/ansi_off", "reason": "SELECT hash('Spark', INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "hash#845996a4629b/ansi_on", - "reason": "SELECT hash('Spark', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#845996a4629b/ansi_off", - "reason": "SELECT hash('Spark', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#8f28ae489069/ansi_on", - "reason": "SELECT hash('Spark', array(123), CAST(NULL AS int)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#8f28ae489069/ansi_off", - "reason": "SELECT hash('Spark', array(123), CAST(NULL AS int)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#9064665edbfa/ansi_on", - "reason": "SELECT hash(' \\t a\\u3000\\n ', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#9064665edbfa/ansi_off", - "reason": "SELECT hash(' \\t a\\u3000\\n ', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#917eb41cb472/ansi_on", - "reason": "SELECT hash(CAST(1 AS SMALLINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#917eb41cb472/ansi_off", - "reason": "SELECT hash(CAST(1 AS SMALLINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#92152fb6e67b/ansi_on", - "reason": "SELECT hash('Spark', array(123), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#92152fb6e67b/ansi_off", - "reason": "SELECT hash('Spark', array(123), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#96987ccd7021/ansi_on", - "reason": "SELECT hash(array(1, 2), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#96987ccd7021/ansi_off", - "reason": "SELECT hash(array(1, 2), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#98df9e5ecfbd/ansi_on", - "reason": "SELECT hash('Spark', array(123), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#98df9e5ecfbd/ansi_off", - "reason": "SELECT hash('Spark', array(123), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#9b5eaf237af0/ansi_on", - "reason": "SELECT hash(1L, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#9b5eaf237af0/ansi_off", - "reason": "SELECT hash(1L, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#a188de4365ba/ansi_on", - "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS DECIMAL(10,2))) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#a188de4365ba/ansi_off", - "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS DECIMAL(10,2))) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#a2161c8521d0/ansi_on", - "reason": "SELECT hash('Spark', array(123), CAST(2147483647 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#a2161c8521d0/ansi_off", - "reason": "SELECT hash('Spark', array(123), CAST(2147483647 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#a3ecac8e4a34/ansi_on", - "reason": "SELECT hash(CAST(1 AS TINYINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#a3ecac8e4a34/ansi_off", - "reason": "SELECT hash(CAST(1 AS TINYINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#a93fbeb6bcb3/ansi_on", - "reason": "SELECT hash('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#a93fbeb6bcb3/ansi_off", - "reason": "SELECT hash('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "hash#ab6c7c5a6f40/ansi_on", "reason": "SELECT hash('Spark', INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -360,46 +72,6 @@ "id": "hash#adbe9020216d/ansi_off", "reason": "SELECT hash('Spark', array(123), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "hash#b0f0a6b58919/ansi_on", - "reason": "SELECT hash('', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#b0f0a6b58919/ansi_off", - "reason": "SELECT hash('', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#b5e5daa7ad5f/ansi_on", - "reason": "SELECT hash(CAST(1.5 AS DECIMAL(38,18)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#b5e5daa7ad5f/ansi_off", - "reason": "SELECT hash(CAST(1.5 AS DECIMAL(38,18)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#bca5749aac50/ansi_on", - "reason": "SELECT hash('Spark', array(123), true) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#bca5749aac50/ansi_off", - "reason": "SELECT hash('Spark', array(123), true) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#be26072f51ea/ansi_on", - "reason": "SELECT hash('Spark', CAST(array(NULL) AS array), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#be26072f51ea/ansi_off", - "reason": "SELECT hash('Spark', CAST(array(NULL) AS array), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#cca3887f32a9/ansi_on", - "reason": "SELECT hash(CAST(1.5 AS DECIMAL(10,2)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#cca3887f32a9/ansi_off", - "reason": "SELECT hash(CAST(1.5 AS DECIMAL(10,2)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "hash#ce8dfe4ae46a/ansi_on", "reason": "SELECT hash(INTERVAL '1-2' YEAR TO MONTH, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -408,30 +80,6 @@ "id": "hash#ce8dfe4ae46a/ansi_off", "reason": "SELECT hash(INTERVAL '1-2' YEAR TO MONTH, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "hash#cf54e7b823e9/ansi_on", - "reason": "SELECT hash(1.5D, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#cf54e7b823e9/ansi_off", - "reason": "SELECT hash(1.5D, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#d8fe25feb621/ansi_on", - "reason": "SELECT hash(CAST(X'C328FF' AS STRING), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#d8fe25feb621/ansi_off", - "reason": "SELECT hash(CAST(X'C328FF' AS STRING), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#dca435a0527c/ansi_on", - "reason": "SELECT hash(true, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#dca435a0527c/ansi_off", - "reason": "SELECT hash(true, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "hash#dd8381fee2e5/ansi_on", "reason": "SELECT hash('Spark', named_struct('a', 1, 'b', 'x'), 2) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" @@ -440,29 +88,13 @@ "id": "hash#dd8381fee2e5/ansi_off", "reason": "SELECT hash('Spark', named_struct('a', 1, 'b', 'x'), 2) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" }, - { - "id": "hash#e450fde5e857/ansi_on", - "reason": "SELECT hash('Spark', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#e450fde5e857/ansi_off", - "reason": "SELECT hash('Spark', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "hash#f0c7f0566e00/ansi_on", - "reason": "SELECT hash('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT hash('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "hash#f0c7f0566e00/ansi_off", - "reason": "SELECT hash('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" - }, - { - "id": "hash#f8a07689fe61/ansi_on", - "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS DECIMAL(38,18))) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "hash#f8a07689fe61/ansi_off", - "reason": "SELECT hash('Spark', array(123), CAST(1.5 AS DECIMAL(38,18))) | KRISHIV_UNSUPPORTED_FEATURE: function array" + "reason": "SELECT hash('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/hex.json b/tests/fixtures/analysis/registry-matrix/hex.json index 6ee27a333..213e92717 100644 --- a/tests/fixtures/analysis/registry-matrix/hex.json +++ b/tests/fixtures/analysis/registry-matrix/hex.json @@ -31,14 +31,6 @@ { "id": "hex#990c738c9ac5/ansi_off", "reason": "SELECT hex(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "hex#a8eccfab7f94/ansi_on", - "reason": "SELECT hex(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "hex#a8eccfab7f94/ansi_off", - "reason": "SELECT hex(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/hour.json b/tests/fixtures/analysis/registry-matrix/hour.json index f52af9c66..9f81a493d 100644 --- a/tests/fixtures/analysis/registry-matrix/hour.json +++ b/tests/fixtures/analysis/registry-matrix/hour.json @@ -8,14 +8,6 @@ "id": "hour#07c6294f169d/ansi_off", "reason": "SELECT hour(CAST(NULL AS time(6))) | parse: KRISHIV_UNSUPPORTED_FEATURE: the time data type (\"TIME\") where Spark has UNSUPPORTED_TIME_TYPE" }, - { - "id": "hour#207d9afe7813/ansi_on", - "reason": "SELECT hour(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "hour#207d9afe7813/ansi_off", - "reason": "SELECT hour(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "hour#764b1ec0e160/ansi_on", "reason": "SELECT hour(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/hypot.json b/tests/fixtures/analysis/registry-matrix/hypot.json index ec6498cc4..ceb0b0925 100644 --- a/tests/fixtures/analysis/registry-matrix/hypot.json +++ b/tests/fixtures/analysis/registry-matrix/hypot.json @@ -40,14 +40,6 @@ "id": "hypot#5c6c6b1a9581/ansi_off", "reason": "SELECT hypot(map('a', 1), 4) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "hypot#5ef785b91579/ansi_on", - "reason": "SELECT hypot(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "hypot#5ef785b91579/ansi_off", - "reason": "SELECT hypot(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "hypot#8ffd180f8baa/ansi_on", "reason": "SELECT hypot(3, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -71,14 +63,6 @@ { "id": "hypot#e8004c8b463f/ansi_off", "reason": "SELECT hypot(named_struct('a', 1, 'b', 'x'), 4) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "hypot#f42712dc9ca1/ansi_on", - "reason": "SELECT hypot(array(1, 2), 4) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "hypot#f42712dc9ca1/ansi_off", - "reason": "SELECT hypot(array(1, 2), 4) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/if.json b/tests/fixtures/analysis/registry-matrix/if.json index 12e583a31..521ba1b89 100644 --- a/tests/fixtures/analysis/registry-matrix/if.json +++ b/tests/fixtures/analysis/registry-matrix/if.json @@ -56,14 +56,6 @@ "id": "if#64a43efb90e0/ansi_off", "reason": "SELECT if(INTERVAL '1 02:03:04' DAY TO SECOND, 'a', 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "if#7ffb9c5e13de/ansi_on", - "reason": "SELECT if(array(1, 2), 'a', 'b') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "if#7ffb9c5e13de/ansi_off", - "reason": "SELECT if(array(1, 2), 'a', 'b') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "if#9d1d0cac3e7d/ansi_on", "reason": "SELECT if(1 < 2, INTERVAL '1-2' YEAR TO MONTH, 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -80,14 +72,6 @@ "id": "if#a6ee2987c105/ansi_off", "reason": "SELECT if(1 < 2, 'a', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "if#b47b88b41f36/ansi_on", - "reason": "SELECT if(1 < 2, 'a', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "if#b47b88b41f36/ansi_off", - "reason": "SELECT if(1 < 2, 'a', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "if#b6e3ea7b11fd/ansi_on", "reason": "SELECT if(1 < 2, INTERVAL '1 02:03:04' DAY TO SECOND, 'b') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -104,14 +88,6 @@ "id": "if#d83245d4f93d/ansi_off", "reason": "SELECT if(1 < 2, named_struct('a', 1, 'b', 'x'), 'b') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "if#da00eb044050/ansi_on", - "reason": "SELECT if(1 < 2, array(1, 2), 'b') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "if#da00eb044050/ansi_off", - "reason": "SELECT if(1 < 2, array(1, 2), 'b') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "if#ec0d1d6bf87a/ansi_on", "reason": "SELECT if(map('a', 1), 'a', 'b') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/ifnull.json b/tests/fixtures/analysis/registry-matrix/ifnull.json index 68a219829..f123ce7ac 100644 --- a/tests/fixtures/analysis/registry-matrix/ifnull.json +++ b/tests/fixtures/analysis/registry-matrix/ifnull.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "ifnull#01f264e6f2a4/ansi_on", - "reason": "SELECT ifnull(CAST(1.5 AS DECIMAL(10,2)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#01f264e6f2a4/ansi_off", - "reason": "SELECT ifnull(CAST(1.5 AS DECIMAL(10,2)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "ifnull#1901fc2f1759/ansi_on", "reason": "SELECT ifnull(INTERVAL '1-2' YEAR TO MONTH, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -16,22 +8,6 @@ "id": "ifnull#1901fc2f1759/ansi_off", "reason": "SELECT ifnull(INTERVAL '1-2' YEAR TO MONTH, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "ifnull#1bf265d2ee73/ansi_on", - "reason": "SELECT ifnull(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#1bf265d2ee73/ansi_off", - "reason": "SELECT ifnull(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#1d03a62f2a6d/ansi_on", - "reason": "SELECT ifnull(true, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#1d03a62f2a6d/ansi_off", - "reason": "SELECT ifnull(true, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "ifnull#24f22a74561c/ansi_on", "reason": "SELECT ifnull(named_struct('a', 1, 'b', 'x'), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -64,126 +40,6 @@ "id": "ifnull#5c3f20483580/ansi_off", "reason": "SELECT ifnull(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "ifnull#679800a7c1ba/ansi_on", - "reason": "SELECT ifnull('abc', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#679800a7c1ba/ansi_off", - "reason": "SELECT ifnull('abc', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#6dc84bc76ae3/ansi_on", - "reason": "SELECT ifnull(1.5D, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#6dc84bc76ae3/ansi_off", - "reason": "SELECT ifnull(1.5D, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#720f10b049a9/ansi_on", - "reason": "SELECT ifnull(CAST(1 AS TINYINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#720f10b049a9/ansi_off", - "reason": "SELECT ifnull(CAST(1 AS TINYINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#7328caa97776/ansi_on", - "reason": "SELECT ifnull(DATE'2024-02-29', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#7328caa97776/ansi_off", - "reason": "SELECT ifnull(DATE'2024-02-29', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#733b0fdc47e4/ansi_on", - "reason": "SELECT ifnull('1', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#733b0fdc47e4/ansi_off", - "reason": "SELECT ifnull('1', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#780c7d54a3ff/ansi_on", - "reason": "SELECT ifnull(1L, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#780c7d54a3ff/ansi_off", - "reason": "SELECT ifnull(1L, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#828551fc1860/ansi_on", - "reason": "SELECT ifnull(X'01', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#828551fc1860/ansi_off", - "reason": "SELECT ifnull(X'01', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#86e8390fb86e/ansi_on", - "reason": "SELECT ifnull(NULL, CAST(array() AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "ifnull#86e8390fb86e/ansi_off", - "reason": "SELECT ifnull(NULL, CAST(array() AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "ifnull#968ad8ccd489/ansi_on", - "reason": "SELECT ifnull(NULL, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "ifnull#968ad8ccd489/ansi_off", - "reason": "SELECT ifnull(NULL, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "ifnull#969ba6758881/ansi_on", - "reason": "SELECT ifnull(NULL, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "ifnull#969ba6758881/ansi_off", - "reason": "SELECT ifnull(NULL, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "ifnull#a00353742167/ansi_on", - "reason": "SELECT ifnull(CAST(1 AS SMALLINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#a00353742167/ansi_off", - "reason": "SELECT ifnull(CAST(1 AS SMALLINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#b21b1a45795f/ansi_on", - "reason": "SELECT ifnull(CAST(1.5 AS FLOAT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#b21b1a45795f/ansi_off", - "reason": "SELECT ifnull(CAST(1.5 AS FLOAT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#b2af6cfe400b/ansi_on", - "reason": "SELECT ifnull(NULL, CAST(array(NULL) AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "ifnull#b2af6cfe400b/ansi_off", - "reason": "SELECT ifnull(NULL, CAST(array(NULL) AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "ifnull#bfe8bb89a454/ansi_on", - "reason": "SELECT ifnull(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#bfe8bb89a454/ansi_off", - "reason": "SELECT ifnull(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#c4bb34dbeb36/ansi_on", - "reason": "SELECT ifnull(1, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#c4bb34dbeb36/ansi_off", - "reason": "SELECT ifnull(1, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "ifnull#ca112c5b4ed3/ansi_on", "reason": "SELECT ifnull(NULL, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -200,14 +56,6 @@ "id": "ifnull#d7660483e606/ansi_off", "reason": "SELECT ifnull(NULL, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" }, - { - "id": "ifnull#d840be61918f/ansi_on", - "reason": "SELECT ifnull(array(1, 2), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "ifnull#d840be61918f/ansi_off", - "reason": "SELECT ifnull(array(1, 2), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "ifnull#e500a975bbe1/ansi_on", "reason": "SELECT ifnull(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -215,14 +63,6 @@ { "id": "ifnull#e500a975bbe1/ansi_off", "reason": "SELECT ifnull(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "ifnull#f5e830f1e7fe/ansi_on", - "reason": "SELECT ifnull(CAST(1.5 AS DECIMAL(38,18)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "ifnull#f5e830f1e7fe/ansi_off", - "reason": "SELECT ifnull(CAST(1.5 AS DECIMAL(38,18)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/isnan.json b/tests/fixtures/analysis/registry-matrix/isnan.json index 5076e1454..ef631adda 100644 --- a/tests/fixtures/analysis/registry-matrix/isnan.json +++ b/tests/fixtures/analysis/registry-matrix/isnan.json @@ -24,14 +24,6 @@ "id": "isnan#5ce0c7195c83/ansi_off", "reason": "SELECT isnan(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "isnan#6aaa7975e1b0/ansi_on", - "reason": "SELECT isnan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "isnan#6aaa7975e1b0/ansi_off", - "reason": "SELECT isnan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "isnan#f996f90ad990/ansi_on", "reason": "SELECT isnan(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/isnotnull.json b/tests/fixtures/analysis/registry-matrix/isnotnull.json index 9463d36a3..b25848ac9 100644 --- a/tests/fixtures/analysis/registry-matrix/isnotnull.json +++ b/tests/fixtures/analysis/registry-matrix/isnotnull.json @@ -24,14 +24,6 @@ "id": "isnotnull#72997046ecf4/ansi_off", "reason": "SELECT isnotnull(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "isnotnull#bf55c5b9fec9/ansi_on", - "reason": "SELECT isnotnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "isnotnull#bf55c5b9fec9/ansi_off", - "reason": "SELECT isnotnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "isnotnull#e9c8cf75daa7/ansi_on", "reason": "SELECT isnotnull(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" diff --git a/tests/fixtures/analysis/registry-matrix/isnull.json b/tests/fixtures/analysis/registry-matrix/isnull.json index 7c65e966f..75c03d7ce 100644 --- a/tests/fixtures/analysis/registry-matrix/isnull.json +++ b/tests/fixtures/analysis/registry-matrix/isnull.json @@ -16,14 +16,6 @@ "id": "isnull#2013e66b962e/ansi_off", "reason": "SELECT isnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" }, - { - "id": "isnull#3b045f12ca67/ansi_on", - "reason": "SELECT isnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "isnull#3b045f12ca67/ansi_off", - "reason": "SELECT isnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "isnull#56c254dd036b/ansi_on", "reason": "SELECT isnull(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/last.json b/tests/fixtures/analysis/registry-matrix/last.json index 9b48370af..dcfdb3509 100644 --- a/tests/fixtures/analysis/registry-matrix/last.json +++ b/tests/fixtures/analysis/registry-matrix/last.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "last#14e29c30b9be/ansi_on", - "reason": "SELECT last(col, array(1, 2)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "last#14e29c30b9be/ansi_off", - "reason": "SELECT last(col, array(1, 2)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" - }, { "id": "last#63f16e2e35b3/ansi_on", "reason": "SELECT last(col, INTERVAL '1-2' YEAR TO MONTH) FROM VALUES (10), (5), (NULL) AS tab(col) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has _LEGACY_ERROR_TEMP_1210" diff --git a/tests/fixtures/analysis/registry-matrix/last_day.json b/tests/fixtures/analysis/registry-matrix/last_day.json index 02fc7d297..1dda50d61 100644 --- a/tests/fixtures/analysis/registry-matrix/last_day.json +++ b/tests/fixtures/analysis/registry-matrix/last_day.json @@ -16,14 +16,6 @@ "id": "last_day#6952126118a9/ansi_off", "reason": "SELECT last_day(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "last_day#93f4e80f80b9/ansi_on", - "reason": "SELECT last_day(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "last_day#93f4e80f80b9/ansi_off", - "reason": "SELECT last_day(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "last_day#ccb5b77f56ff/ansi_on", "reason": "SELECT last_day(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/last_value.json b/tests/fixtures/analysis/registry-matrix/last_value.json index 00475416b..b2a6fbbb5 100644 --- a/tests/fixtures/analysis/registry-matrix/last_value.json +++ b/tests/fixtures/analysis/registry-matrix/last_value.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "last_value#2b628baff52d/ansi_on", - "reason": "SELECT last_value(col, array(1, 2)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" - }, - { - "id": "last_value#2b628baff52d/ansi_off", - "reason": "SELECT last_value(col, array(1, 2)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has _LEGACY_ERROR_TEMP_1210" - }, { "id": "last_value#59116f565aa7/ansi_on", "reason": "SELECT last_value(col, map('a', 1)) FROM VALUES (10), (5), (NULL) AS tab(col) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has _LEGACY_ERROR_TEMP_1210" diff --git a/tests/fixtures/analysis/registry-matrix/lcase.json b/tests/fixtures/analysis/registry-matrix/lcase.json index 464c52b59..680351695 100644 --- a/tests/fixtures/analysis/registry-matrix/lcase.json +++ b/tests/fixtures/analysis/registry-matrix/lcase.json @@ -8,14 +8,6 @@ "id": "lcase#5f8ebfb97b33/ansi_off", "reason": "SELECT lcase(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "lcase#77b7ee7da5a4/ansi_on", - "reason": "SELECT lcase(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lcase#77b7ee7da5a4/ansi_off", - "reason": "SELECT lcase(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "lcase#a43c0260bd5e/ansi_on", "reason": "SELECT lcase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/least.json b/tests/fixtures/analysis/registry-matrix/least.json index 64662ce00..6be6e4461 100644 --- a/tests/fixtures/analysis/registry-matrix/least.json +++ b/tests/fixtures/analysis/registry-matrix/least.json @@ -40,14 +40,6 @@ "id": "least#4b20b2ccd6ae/ansi_off", "reason": "SELECT least(10, 9, named_struct('a', 1, 'b', 'x'), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "least#4bc4ee9d81f5/ansi_on", - "reason": "SELECT least(10, 9, array(1, 2), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "least#4bc4ee9d81f5/ansi_off", - "reason": "SELECT least(10, 9, array(1, 2), 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "least#4ded5ea86b66/ansi_on", "reason": "SELECT least(10, INTERVAL '1-2' YEAR TO MONTH, 2, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -104,22 +96,6 @@ "id": "least#73730af25057/ansi_off", "reason": "SELECT least(10, 9, 2, INTERVAL '1 02:03:04' DAY TO SECOND, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "least#7bf55f7932df/ansi_on", - "reason": "SELECT least(array(1, 2), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "least#7bf55f7932df/ansi_off", - "reason": "SELECT least(array(1, 2), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "least#7e2c5fcaa68d/ansi_on", - "reason": "SELECT least(10, 9, 2, 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "least#7e2c5fcaa68d/ansi_off", - "reason": "SELECT least(10, 9, 2, 4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "least#803606ea5b42/ansi_on", "reason": "SELECT least(10, 9, INTERVAL '1-2' YEAR TO MONTH, 4, 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -136,14 +112,6 @@ "id": "least#844d108891b5/ansi_off", "reason": "SELECT least(10, 9, 2, 4, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "least#b278e45a69a6/ansi_on", - "reason": "SELECT least(10, array(1, 2), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "least#b278e45a69a6/ansi_off", - "reason": "SELECT least(10, array(1, 2), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "least#c0cc79f3906c/ansi_on", "reason": "SELECT least(named_struct('a', 1, 'b', 'x'), 9, 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -176,14 +144,6 @@ "id": "least#eb6e2c2c1be6/ansi_off", "reason": "SELECT least(10, map('a', 1), 2, 4, 3) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "least#ee82fb8da979/ansi_on", - "reason": "SELECT least(10, 9, 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "least#ee82fb8da979/ansi_off", - "reason": "SELECT least(10, 9, 2, array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "least#f966d17db1a4/ansi_on", "reason": "SELECT least(10, 9, 2, 4, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/length.json b/tests/fixtures/analysis/registry-matrix/length.json index dc5cc0307..d579630c6 100644 --- a/tests/fixtures/analysis/registry-matrix/length.json +++ b/tests/fixtures/analysis/registry-matrix/length.json @@ -8,14 +8,6 @@ "id": "length#3850ba7284e8/ansi_off", "reason": "SELECT length(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "length#55ae664eebe8/ansi_on", - "reason": "SELECT length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "length#55ae664eebe8/ansi_off", - "reason": "SELECT length(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "length#c112063cc572/ansi_on", "reason": "SELECT length(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/ln.json b/tests/fixtures/analysis/registry-matrix/ln.json index c95fec762..4a0106942 100644 --- a/tests/fixtures/analysis/registry-matrix/ln.json +++ b/tests/fixtures/analysis/registry-matrix/ln.json @@ -16,14 +16,6 @@ "id": "ln#a4fd4a2aae22/ansi_off", "reason": "SELECT ln(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "ln#b3f8340799d9/ansi_on", - "reason": "SELECT ln(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ln#b3f8340799d9/ansi_off", - "reason": "SELECT ln(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ln#e46d79f0541d/ansi_on", "reason": "SELECT ln(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/log.json b/tests/fixtures/analysis/registry-matrix/log.json index 203c106b4..4f840ea34 100644 --- a/tests/fixtures/analysis/registry-matrix/log.json +++ b/tests/fixtures/analysis/registry-matrix/log.json @@ -8,14 +8,6 @@ "id": "log#2849851ffff9/ansi_off", "reason": "SELECT log(10, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "log#5c08d869324e/ansi_on", - "reason": "SELECT log(10, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "log#5c08d869324e/ansi_off", - "reason": "SELECT log(10, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "log#6e4cd2e20dbf/ansi_on", "reason": "SELECT log(10, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -48,14 +40,6 @@ "id": "log#94eb25460542/ansi_off", "reason": "SELECT log(map('a', 1), 100) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "log#97df9415f277/ansi_on", - "reason": "SELECT log(array(1, 2), 100) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "log#97df9415f277/ansi_off", - "reason": "SELECT log(array(1, 2), 100) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "log#b29ab2f7e498/ansi_on", "reason": "SELECT log(INTERVAL '1 02:03:04' DAY TO SECOND, 100) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/log10.json b/tests/fixtures/analysis/registry-matrix/log10.json index 279c4947c..425e2a72d 100644 --- a/tests/fixtures/analysis/registry-matrix/log10.json +++ b/tests/fixtures/analysis/registry-matrix/log10.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "log10#0ed43d169a69/ansi_on", - "reason": "SELECT log10(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "log10#0ed43d169a69/ansi_off", - "reason": "SELECT log10(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "log10#3dd195121d90/ansi_on", "reason": "SELECT log10(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/log1p.json b/tests/fixtures/analysis/registry-matrix/log1p.json index 29769929a..8a297c241 100644 --- a/tests/fixtures/analysis/registry-matrix/log1p.json +++ b/tests/fixtures/analysis/registry-matrix/log1p.json @@ -24,14 +24,6 @@ "id": "log1p#862526b1964b/ansi_off", "reason": "SELECT log1p(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "log1p#c2048815afbc/ansi_on", - "reason": "SELECT log1p(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "log1p#c2048815afbc/ansi_off", - "reason": "SELECT log1p(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "log1p#e515b0029715/ansi_on", "reason": "SELECT log1p(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/log2.json b/tests/fixtures/analysis/registry-matrix/log2.json index 93ec70f6f..e6ec3d0cd 100644 --- a/tests/fixtures/analysis/registry-matrix/log2.json +++ b/tests/fixtures/analysis/registry-matrix/log2.json @@ -31,14 +31,6 @@ { "id": "log2#bbf88b925e49/ansi_off", "reason": "SELECT log2(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "log2#dac3f570d59f/ansi_on", - "reason": "SELECT log2(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "log2#dac3f570d59f/ansi_off", - "reason": "SELECT log2(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/lower.json b/tests/fixtures/analysis/registry-matrix/lower.json index 9e9308f55..973688c8f 100644 --- a/tests/fixtures/analysis/registry-matrix/lower.json +++ b/tests/fixtures/analysis/registry-matrix/lower.json @@ -24,14 +24,6 @@ "id": "lower#3e7f165b4997/ansi_off", "reason": "SELECT lower(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "lower#4feea7924ff5/ansi_on", - "reason": "SELECT lower(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lower#4feea7924ff5/ansi_off", - "reason": "SELECT lower(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "lower#f2581497b448/ansi_on", "reason": "SELECT lower(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/lpad.json b/tests/fixtures/analysis/registry-matrix/lpad.json index 727e618d2..635c4ea0a 100644 --- a/tests/fixtures/analysis/registry-matrix/lpad.json +++ b/tests/fixtures/analysis/registry-matrix/lpad.json @@ -1,21 +1,5 @@ { "entries": [ - { - "id": "lpad#16dc5b3fef4f/ansi_on", - "reason": "SELECT lpad('hi', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#16dc5b3fef4f/ansi_off", - "reason": "SELECT lpad('hi', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#2b87c9084c86/ansi_on", - "reason": "SELECT lpad('hi', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#2b87c9084c86/ansi_off", - "reason": "SELECT lpad('hi', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "lpad#2ec7eb553107/ansi_on", "reason": "SELECT lpad(INTERVAL '1-2' YEAR TO MONTH, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -24,14 +8,6 @@ "id": "lpad#2ec7eb553107/ansi_off", "reason": "SELECT lpad(INTERVAL '1-2' YEAR TO MONTH, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "lpad#36216c6c2a17/ansi_on", - "reason": "SELECT lpad(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#36216c6c2a17/ansi_off", - "reason": "SELECT lpad(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "lpad#39b23190194f/ansi_on", "reason": "SELECT lpad('hi', 5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -48,14 +24,6 @@ "id": "lpad#410a80e8c9ac/ansi_off", "reason": "SELECT lpad('hi', INTERVAL '1 02:03:04' DAY TO SECOND, '??') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "lpad#467f5d66c343/ansi_on", - "reason": "SELECT lpad(array(1, 2), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#467f5d66c343/ansi_off", - "reason": "SELECT lpad(array(1, 2), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "lpad#488701c681e3/ansi_on", "reason": "SELECT lpad(named_struct('a', 1, 'b', 'x'), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -96,14 +64,6 @@ "id": "lpad#7a419bc53ab4/ansi_off", "reason": "SELECT lpad(map('a', 1), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "lpad#7fbbfc2d5d70/ansi_on", - "reason": "SELECT lpad('hi', array(1, 2), '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "lpad#7fbbfc2d5d70/ansi_off", - "reason": "SELECT lpad('hi', array(1, 2), '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "lpad#86f3021e158c/ansi_on", "reason": "SELECT lpad(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/ltrim.json b/tests/fixtures/analysis/registry-matrix/ltrim.json index 7776e8985..1b4088e14 100644 --- a/tests/fixtures/analysis/registry-matrix/ltrim.json +++ b/tests/fixtures/analysis/registry-matrix/ltrim.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "ltrim#1619a3484678/ansi_on", - "reason": "SELECT ltrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ltrim#1619a3484678/ansi_off", - "reason": "SELECT ltrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ltrim#6225b3289404/ansi_on", "reason": "SELECT ltrim(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/make_date.json b/tests/fixtures/analysis/registry-matrix/make_date.json index 724e8a9c1..4eb1ad134 100644 --- a/tests/fixtures/analysis/registry-matrix/make_date.json +++ b/tests/fixtures/analysis/registry-matrix/make_date.json @@ -72,22 +72,6 @@ "id": "make_date#65c3a9e68abf/ansi_off", "reason": "SELECT make_date(map('a', 1), 7, 15) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "make_date#670b553cefcd/ansi_on", - "reason": "SELECT make_date(2013, array(1, 2), 15) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "make_date#670b553cefcd/ansi_off", - "reason": "SELECT make_date(2013, array(1, 2), 15) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "make_date#71717f95eb32/ansi_on", - "reason": "SELECT make_date(2013, 7, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "make_date#71717f95eb32/ansi_off", - "reason": "SELECT make_date(2013, 7, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "make_date#962428ae5586/ansi_on", "reason": "SELECT make_date(2013, 7, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -111,14 +95,6 @@ { "id": "make_date#df298d18b826/ansi_off", "reason": "SELECT make_date(INTERVAL '1-2' YEAR TO MONTH, 7, 15) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "make_date#e5d50aae8051/ansi_on", - "reason": "SELECT make_date(array(1, 2), 7, 15) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "make_date#e5d50aae8051/ansi_off", - "reason": "SELECT make_date(array(1, 2), 7, 15) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/max_by.json b/tests/fixtures/analysis/registry-matrix/max_by.json index b613d1da0..30b5ccd9b 100644 --- a/tests/fixtures/analysis/registry-matrix/max_by.json +++ b/tests/fixtures/analysis/registry-matrix/max_by.json @@ -186,11 +186,11 @@ }, { "id": "max_by#f0872159688c/ansi_on", - "reason": "SELECT max_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT max_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "max_by#f0872159688c/ansi_off", - "reason": "SELECT max_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT max_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "max_by#ff115f23cf8f/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/md5.json b/tests/fixtures/analysis/registry-matrix/md5.json index a41bb5cc3..9b3ce97ab 100644 --- a/tests/fixtures/analysis/registry-matrix/md5.json +++ b/tests/fixtures/analysis/registry-matrix/md5.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "md5#494fc1423cbf/ansi_on", - "reason": "SELECT md5(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "md5#494fc1423cbf/ansi_off", - "reason": "SELECT md5(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "md5#68d5a24755f1/ansi_on", "reason": "SELECT md5(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/min_by.json b/tests/fixtures/analysis/registry-matrix/min_by.json index e826ec155..8508ea26c 100644 --- a/tests/fixtures/analysis/registry-matrix/min_by.json +++ b/tests/fixtures/analysis/registry-matrix/min_by.json @@ -90,11 +90,11 @@ }, { "id": "min_by#80d0ca30807a/ansi_on", - "reason": "SELECT min_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT min_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "min_by#80d0ca30807a/ansi_off", - "reason": "SELECT min_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT min_by(x, y, array(1, 2)) FROM VALUES ('a', 10), ('b', 50), ('c', 20) AS tab(x, y) | KRISHIV_UNSUPPORTED_FEATURE: max_by and min_by with a third argument (they return an array) where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "min_by#897e17cdfb93/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/minute.json b/tests/fixtures/analysis/registry-matrix/minute.json index e8a32b4ac..ee465b182 100644 --- a/tests/fixtures/analysis/registry-matrix/minute.json +++ b/tests/fixtures/analysis/registry-matrix/minute.json @@ -8,14 +8,6 @@ "id": "minute#4480f918603c/ansi_off", "reason": "SELECT minute(CAST(NULL AS time(6))) | parse: KRISHIV_UNSUPPORTED_FEATURE: the time data type (\"TIME\") where Spark has UNSUPPORTED_TIME_TYPE" }, - { - "id": "minute#73d04a408bd8/ansi_on", - "reason": "SELECT minute(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "minute#73d04a408bd8/ansi_off", - "reason": "SELECT minute(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "minute#7cec507eaf54/ansi_on", "reason": "SELECT minute(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/mod.json b/tests/fixtures/analysis/registry-matrix/mod.json index 0b9e90de6..436887b75 100644 --- a/tests/fixtures/analysis/registry-matrix/mod.json +++ b/tests/fixtures/analysis/registry-matrix/mod.json @@ -28,14 +28,6 @@ "id": "mod#4fa2d83805ae/ansi_off", "reason": "SELECT MOD('abc', 1.8) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "id": "mod#50bf39e335f1/ansi_on", - "reason": "SELECT MOD(array(1, 2), 1.8) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "mod#50bf39e335f1/ansi_off", - "reason": "SELECT MOD(array(1, 2), 1.8) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "mod#5fe5533591e7/ansi_on", "reason": "SELECT MOD(INTERVAL '1-2' YEAR TO MONTH, 1.8) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" @@ -80,14 +72,6 @@ "id": "mod#c846ac62379a/ansi_off", "reason": "SELECT MOD(2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "mod#d3dc388a8ea9/ansi_on", - "reason": "SELECT MOD(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "mod#d3dc388a8ea9/ansi_off", - "reason": "SELECT MOD(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "mod#d6971a885eed/ansi_on", "reason": "SELECT MOD(named_struct('a', 1, 'b', 'x'), 1.8) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/month.json b/tests/fixtures/analysis/registry-matrix/month.json index 22b2dfff0..854170516 100644 --- a/tests/fixtures/analysis/registry-matrix/month.json +++ b/tests/fixtures/analysis/registry-matrix/month.json @@ -24,14 +24,6 @@ "id": "month#5f9cb2792de7/ansi_off", "reason": "SELECT month(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "month#65bec69f1710/ansi_on", - "reason": "SELECT month(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "month#65bec69f1710/ansi_off", - "reason": "SELECT month(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "month#8a56108c2560/ansi_on", "reason": "SELECT month(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/monthname.json b/tests/fixtures/analysis/registry-matrix/monthname.json index 89ad7de49..43531ffca 100644 --- a/tests/fixtures/analysis/registry-matrix/monthname.json +++ b/tests/fixtures/analysis/registry-matrix/monthname.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "monthname#370266c7abd2/ansi_on", - "reason": "SELECT monthname(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "monthname#370266c7abd2/ansi_off", - "reason": "SELECT monthname(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "monthname#3de4a1bb6046/ansi_on", "reason": "SELECT monthname(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/months_between.json b/tests/fixtures/analysis/registry-matrix/months_between.json index c1823bd2f..e7c031de6 100644 --- a/tests/fixtures/analysis/registry-matrix/months_between.json +++ b/tests/fixtures/analysis/registry-matrix/months_between.json @@ -8,14 +8,6 @@ "id": "months_between#134fa8953972/ansi_off", "reason": "SELECT months_between(named_struct('a', 1, 'b', 'x'), '1996-10-30', false) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "months_between#14b4c46552c5/ansi_on", - "reason": "SELECT months_between(array(1, 2), '1996-10-30', false) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#14b4c46552c5/ansi_off", - "reason": "SELECT months_between(array(1, 2), '1996-10-30', false) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "months_between#1cf30befe281/ansi_on", "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -24,14 +16,6 @@ "id": "months_between#1cf30befe281/ansi_off", "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "months_between#1d6c07f4a83a/ansi_on", - "reason": "SELECT months_between(array(1, 2), '1996-10-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#1d6c07f4a83a/ansi_off", - "reason": "SELECT months_between(array(1, 2), '1996-10-30') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "months_between#1de399a111e8/ansi_on", "reason": "SELECT months_between('1997-02-28 10:30:00', map('a', 1), false) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -72,14 +56,6 @@ "id": "months_between#3b4d3579db12/ansi_off", "reason": "SELECT months_between(INTERVAL '1 02:03:04' DAY TO SECOND, '1996-10-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "months_between#41c7765d7848/ansi_on", - "reason": "SELECT months_between('1997-02-28 10:30:00', array(1, 2), false) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#41c7765d7848/ansi_off", - "reason": "SELECT months_between('1997-02-28 10:30:00', array(1, 2), false) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "months_between#4aee6056f332/ansi_on", "reason": "SELECT months_between('1997-02-28 10:30:00', INTERVAL '1-2' YEAR TO MONTH, false) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -108,14 +84,6 @@ "id": "months_between#648a4a20f4e8/ansi_off", "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', 'abc') | resolves to double where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "months_between#6668f1e91220/ansi_on", - "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#6668f1e91220/ansi_off", - "reason": "SELECT months_between('1997-02-28 10:30:00', '1996-10-30', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "months_between#6955e166bd2c/ansi_on", "reason": "SELECT months_between(INTERVAL '1-2' YEAR TO MONTH, '1996-10-30') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -168,14 +136,6 @@ "id": "months_between#ad7e3fced174/ansi_off", "reason": "SELECT months_between(map('a', 1), '1996-10-30', false) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "months_between#bb82f2d9bdb8/ansi_on", - "reason": "SELECT months_between('1997-02-28 10:30:00', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "months_between#bb82f2d9bdb8/ansi_off", - "reason": "SELECT months_between('1997-02-28 10:30:00', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "months_between#c35328709bd8/ansi_on", "reason": "SELECT months_between(INTERVAL '1-2' YEAR TO MONTH, '1996-10-30', false) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/nanvl.json b/tests/fixtures/analysis/registry-matrix/nanvl.json index 503f6c6ad..23e79a337 100644 --- a/tests/fixtures/analysis/registry-matrix/nanvl.json +++ b/tests/fixtures/analysis/registry-matrix/nanvl.json @@ -16,14 +16,6 @@ "id": "nanvl#224c752cdc8a/ansi_off", "reason": "SELECT nanvl(map('a', 1), 123) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "nanvl#644ae139b068/ansi_on", - "reason": "SELECT nanvl(array(1, 2), 123) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "nanvl#644ae139b068/ansi_off", - "reason": "SELECT nanvl(array(1, 2), 123) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "nanvl#6f856e44bbc3/ansi_on", "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" @@ -56,14 +48,6 @@ "id": "nanvl#a3508ade0a62/ansi_off", "reason": "SELECT nanvl(named_struct('a', 1, 'b', 'x'), 123) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "nanvl#cc67ce301f92/ansi_on", - "reason": "SELECT nanvl(cast('NaN' as double), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "nanvl#cc67ce301f92/ansi_off", - "reason": "SELECT nanvl(cast('NaN' as double), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "nanvl#e9d2247bde9c/ansi_on", "reason": "SELECT nanvl(cast('NaN' as double), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/negative.json b/tests/fixtures/analysis/registry-matrix/negative.json index 2484a0ed2..f43d9aa7f 100644 --- a/tests/fixtures/analysis/registry-matrix/negative.json +++ b/tests/fixtures/analysis/registry-matrix/negative.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "negative#25a8db9031cd/ansi_on", - "reason": "SELECT negative(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "negative#25a8db9031cd/ansi_off", - "reason": "SELECT negative(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "negative#987900a6d6ac/ansi_on", "reason": "SELECT negative(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/next_day.json b/tests/fixtures/analysis/registry-matrix/next_day.json index 677a9757e..e4f703811 100644 --- a/tests/fixtures/analysis/registry-matrix/next_day.json +++ b/tests/fixtures/analysis/registry-matrix/next_day.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "next_day#11deac4e1b58/ansi_on", - "reason": "SELECT next_day(array(1, 2), 'TU') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "next_day#11deac4e1b58/ansi_off", - "reason": "SELECT next_day(array(1, 2), 'TU') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "next_day#180b8bb25bd8/ansi_on", "reason": "SELECT next_day(INTERVAL '1 02:03:04' DAY TO SECOND, 'TU') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +56,6 @@ "id": "next_day#a62742e67e42/ansi_off", "reason": "SELECT next_day(INTERVAL '1-2' YEAR TO MONTH, 'TU') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "next_day#ba75aedd3a5c/ansi_on", - "reason": "SELECT next_day('2015-01-14', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "next_day#ba75aedd3a5c/ansi_off", - "reason": "SELECT next_day('2015-01-14', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "next_day#fc48ff666ecf/ansi_on", "reason": "SELECT next_day('2015-01-14', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/nth_value.json b/tests/fixtures/analysis/registry-matrix/nth_value.json index 3ce0bdcd9..8d5451a59 100644 --- a/tests/fixtures/analysis/registry-matrix/nth_value.json +++ b/tests/fixtures/analysis/registry-matrix/nth_value.json @@ -42,11 +42,11 @@ }, { "id": "nth_value#9494e9025f5d/ansi_on", - "reason": "SELECT a, b, nth_value(b, array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT a, b, nth_value(b, array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "nth_value#9494e9025f5d/ansi_off", - "reason": "SELECT a, b, nth_value(b, array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT a, b, nth_value(b, array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "nth_value#b7e9ba990e13/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/ntile.json b/tests/fixtures/analysis/registry-matrix/ntile.json index 13ba52b6a..0eb91cc8c 100644 --- a/tests/fixtures/analysis/registry-matrix/ntile.json +++ b/tests/fixtures/analysis/registry-matrix/ntile.json @@ -2,11 +2,11 @@ "entries": [ { "id": "ntile#07ff6bea2932/ansi_on", - "reason": "SELECT a, b, ntile(array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT a, b, ntile(array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "ntile#07ff6bea2932/ansi_off", - "reason": "SELECT a, b, ntile(array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + "reason": "SELECT a, b, ntile(array(1, 2)) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b) | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, { "id": "ntile#2380b319de33/ansi_on", diff --git a/tests/fixtures/analysis/registry-matrix/nullif.json b/tests/fixtures/analysis/registry-matrix/nullif.json index e5919d294..fe4955181 100644 --- a/tests/fixtures/analysis/registry-matrix/nullif.json +++ b/tests/fixtures/analysis/registry-matrix/nullif.json @@ -1,21 +1,5 @@ { "entries": [ - { - "id": "nullif#14e8c8714543/ansi_on", - "reason": "SELECT nullif(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "nullif#14e8c8714543/ansi_off", - "reason": "SELECT nullif(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "nullif#1d230a3a28c9/ansi_on", - "reason": "SELECT nullif(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "nullif#1d230a3a28c9/ansi_off", - "reason": "SELECT nullif(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "nullif#8c6ac4b1f807/ansi_on", "reason": "SELECT nullif(map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/nullifzero.json b/tests/fixtures/analysis/registry-matrix/nullifzero.json index e89f0e755..b9592f9a3 100644 --- a/tests/fixtures/analysis/registry-matrix/nullifzero.json +++ b/tests/fixtures/analysis/registry-matrix/nullifzero.json @@ -16,14 +16,6 @@ "id": "nullifzero#b2fca9a991cf/ansi_off", "reason": "SELECT nullifzero(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "nullifzero#be53c63a1268/ansi_on", - "reason": "SELECT nullifzero(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "nullifzero#be53c63a1268/ansi_off", - "reason": "SELECT nullifzero(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "nullifzero#edaf27aa45a7/ansi_on", "reason": "SELECT nullifzero(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/nvl.json b/tests/fixtures/analysis/registry-matrix/nvl.json index 118e76d11..cd5004816 100644 --- a/tests/fixtures/analysis/registry-matrix/nvl.json +++ b/tests/fixtures/analysis/registry-matrix/nvl.json @@ -1,29 +1,5 @@ { "entries": [ - { - "id": "nvl#0460fbe2242f/ansi_on", - "reason": "SELECT nvl(NULL, CAST(array() AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl#0460fbe2242f/ansi_off", - "reason": "SELECT nvl(NULL, CAST(array() AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl#07bf6900cb48/ansi_on", - "reason": "SELECT nvl(NULL, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl#07bf6900cb48/ansi_off", - "reason": "SELECT nvl(NULL, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl#0f4aeb376d5f/ansi_on", - "reason": "SELECT nvl(CAST(1.5 AS FLOAT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#0f4aeb376d5f/ansi_off", - "reason": "SELECT nvl(CAST(1.5 AS FLOAT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl#13de9ce1fe22/ansi_on", "reason": "SELECT nvl(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -32,30 +8,6 @@ "id": "nvl#13de9ce1fe22/ansi_off", "reason": "SELECT nvl(map('a', 1), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "nvl#18036545751d/ansi_on", - "reason": "SELECT nvl(CAST(1.5 AS DECIMAL(38,18)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#18036545751d/ansi_off", - "reason": "SELECT nvl(CAST(1.5 AS DECIMAL(38,18)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#1cf818db1216/ansi_on", - "reason": "SELECT nvl(X'01', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#1cf818db1216/ansi_off", - "reason": "SELECT nvl(X'01', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#207e88f971e0/ansi_on", - "reason": "SELECT nvl(true, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#207e88f971e0/ansi_off", - "reason": "SELECT nvl(true, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl#2305f5ee469a/ansi_on", "reason": "SELECT nvl(named_struct('a', 1, 'b', 'x'), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -64,30 +16,6 @@ "id": "nvl#2305f5ee469a/ansi_off", "reason": "SELECT nvl(named_struct('a', 1, 'b', 'x'), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "nvl#30624b2144a9/ansi_on", - "reason": "SELECT nvl(CAST(1 AS SMALLINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#30624b2144a9/ansi_off", - "reason": "SELECT nvl(CAST(1 AS SMALLINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#57346bea4d30/ansi_on", - "reason": "SELECT nvl(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#57346bea4d30/ansi_off", - "reason": "SELECT nvl(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#707b2299b507/ansi_on", - "reason": "SELECT nvl(1, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#707b2299b507/ansi_off", - "reason": "SELECT nvl(1, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl#7b57963d6974/ansi_on", "reason": "SELECT nvl(NULL, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" @@ -96,30 +24,6 @@ "id": "nvl#7b57963d6974/ansi_off", "reason": "SELECT nvl(NULL, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" }, - { - "id": "nvl#7cea853582ec/ansi_on", - "reason": "SELECT nvl('1', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#7cea853582ec/ansi_off", - "reason": "SELECT nvl('1', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#880ab25c6d7a/ansi_on", - "reason": "SELECT nvl(NULL, CAST(array(NULL) AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl#880ab25c6d7a/ansi_off", - "reason": "SELECT nvl(NULL, CAST(array(NULL) AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl#90bda17a241c/ansi_on", - "reason": "SELECT nvl(1.5D, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#90bda17a241c/ansi_off", - "reason": "SELECT nvl(1.5D, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl#9e1045de78bd/ansi_on", "reason": "SELECT nvl(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -128,30 +32,6 @@ "id": "nvl#9e1045de78bd/ansi_off", "reason": "SELECT nvl(NULL, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "nvl#9efd37c3d6f2/ansi_on", - "reason": "SELECT nvl(1L, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#9efd37c3d6f2/ansi_off", - "reason": "SELECT nvl(1L, array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#a1c66c5ed996/ansi_on", - "reason": "SELECT nvl(array(1, 2), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl#a1c66c5ed996/ansi_off", - "reason": "SELECT nvl(array(1, 2), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl#a81f8052130a/ansi_on", - "reason": "SELECT nvl('abc', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#a81f8052130a/ansi_off", - "reason": "SELECT nvl('abc', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl#b47cc5fd236f/ansi_on", "reason": "SELECT nvl(INTERVAL '1 02:03:04' DAY TO SECOND, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -160,30 +40,6 @@ "id": "nvl#b47cc5fd236f/ansi_off", "reason": "SELECT nvl(INTERVAL '1 02:03:04' DAY TO SECOND, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "nvl#bcd71d6d3a0f/ansi_on", - "reason": "SELECT nvl(CAST(1 AS TINYINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#bcd71d6d3a0f/ansi_off", - "reason": "SELECT nvl(CAST(1 AS TINYINT), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#c72f6b63d89a/ansi_on", - "reason": "SELECT nvl(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#c72f6b63d89a/ansi_off", - "reason": "SELECT nvl(TIMESTAMP'2024-02-29 12:34:56.123456', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#d2c5155ff20e/ansi_on", - "reason": "SELECT nvl(DATE'2024-02-29', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#d2c5155ff20e/ansi_off", - "reason": "SELECT nvl(DATE'2024-02-29', array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl#d806a1029577/ansi_on", "reason": "SELECT nvl(NULL, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -192,14 +48,6 @@ "id": "nvl#d806a1029577/ansi_off", "reason": "SELECT nvl(NULL, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "nvl#db213cc5bb1d/ansi_on", - "reason": "SELECT nvl(CAST(1.5 AS DECIMAL(10,2)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl#db213cc5bb1d/ansi_off", - "reason": "SELECT nvl(CAST(1.5 AS DECIMAL(10,2)), array('2')) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl#e0e8f9112791/ansi_on", "reason": "SELECT nvl(INTERVAL '1-2' YEAR TO MONTH, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -208,14 +56,6 @@ "id": "nvl#e0e8f9112791/ansi_off", "reason": "SELECT nvl(INTERVAL '1-2' YEAR TO MONTH, array('2')) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "nvl#f89a839e7d85/ansi_on", - "reason": "SELECT nvl(NULL, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl#f89a839e7d85/ansi_off", - "reason": "SELECT nvl(NULL, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "nvl#fd2b816559e6/ansi_on", "reason": "SELECT nvl(NULL, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map" diff --git a/tests/fixtures/analysis/registry-matrix/nvl2.json b/tests/fixtures/analysis/registry-matrix/nvl2.json index 79d1e01cb..af5a1db57 100644 --- a/tests/fixtures/analysis/registry-matrix/nvl2.json +++ b/tests/fixtures/analysis/registry-matrix/nvl2.json @@ -24,14 +24,6 @@ "id": "nvl2#3c48eb611259/ansi_off", "reason": "SELECT nvl2(NULL, named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "nvl2#4e8e95ac7957/ansi_on", - "reason": "SELECT nvl2(NULL, 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl2#4e8e95ac7957/ansi_off", - "reason": "SELECT nvl2(NULL, 2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl2#59e0d7c638d1/ansi_on", "reason": "SELECT nvl2(named_struct('a', 1, 'b', 'x'), 2, 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" @@ -40,14 +32,6 @@ "id": "nvl2#59e0d7c638d1/ansi_off", "reason": "SELECT nvl2(named_struct('a', 1, 'b', 'x'), 2, 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" }, - { - "id": "nvl2#5ba4dfd6249b/ansi_on", - "reason": "SELECT nvl2(array(1, 2), 2, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "nvl2#5ba4dfd6249b/ansi_off", - "reason": "SELECT nvl2(array(1, 2), 2, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "nvl2#92c35e6b7596/ansi_on", "reason": "SELECT nvl2(NULL, map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" @@ -104,14 +88,6 @@ "id": "nvl2#d68aaefed581/ansi_off", "reason": "SELECT nvl2(NULL, INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "nvl2#d91ae78c6447/ansi_on", - "reason": "SELECT nvl2(NULL, array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "nvl2#d91ae78c6447/ansi_off", - "reason": "SELECT nvl2(NULL, array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "nvl2#e7ae2541b711/ansi_on", "reason": "SELECT nvl2(NULL, INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" diff --git a/tests/fixtures/analysis/registry-matrix/pmod.json b/tests/fixtures/analysis/registry-matrix/pmod.json index 2e4e24369..394166269 100644 --- a/tests/fixtures/analysis/registry-matrix/pmod.json +++ b/tests/fixtures/analysis/registry-matrix/pmod.json @@ -4,14 +4,6 @@ "id": "pmod#12b81d80212f/ansi_off", "reason": "SELECT pmod('1', 3) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "id": "pmod#1a3001bfb1af/ansi_on", - "reason": "SELECT pmod(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "pmod#1a3001bfb1af/ansi_off", - "reason": "SELECT pmod(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "pmod#2935dced5960/ansi_on", "reason": "SELECT pmod(named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" @@ -36,14 +28,6 @@ "id": "pmod#41c472d75d53/ansi_off", "reason": "SELECT pmod(10, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "pmod#45933ab5e0c9/ansi_on", - "reason": "SELECT pmod(10, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "pmod#45933ab5e0c9/ansi_off", - "reason": "SELECT pmod(10, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "pmod#4b50b5dc070f/ansi_off", "reason": "SELECT pmod('abc', 3) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" diff --git a/tests/fixtures/analysis/registry-matrix/positive.json b/tests/fixtures/analysis/registry-matrix/positive.json index 048e2e4d7..28b7019a7 100644 --- a/tests/fixtures/analysis/registry-matrix/positive.json +++ b/tests/fixtures/analysis/registry-matrix/positive.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "positive#2925bd78f863/ansi_on", - "reason": "SELECT positive(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "positive#2925bd78f863/ansi_off", - "reason": "SELECT positive(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "positive#66e665f762a8/ansi_on", "reason": "SELECT positive(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/pow.json b/tests/fixtures/analysis/registry-matrix/pow.json index eca6c4ba1..1a136866d 100644 --- a/tests/fixtures/analysis/registry-matrix/pow.json +++ b/tests/fixtures/analysis/registry-matrix/pow.json @@ -63,22 +63,6 @@ { "id": "pow#a5c5256f4fbf/ansi_off", "reason": "SELECT pow(2, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "pow#e67e8e6f1e7e/ansi_on", - "reason": "SELECT pow(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "pow#e67e8e6f1e7e/ansi_off", - "reason": "SELECT pow(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "pow#f94cefe76fff/ansi_on", - "reason": "SELECT pow(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "pow#f94cefe76fff/ansi_off", - "reason": "SELECT pow(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/power.json b/tests/fixtures/analysis/registry-matrix/power.json index a1077a574..64508b9c2 100644 --- a/tests/fixtures/analysis/registry-matrix/power.json +++ b/tests/fixtures/analysis/registry-matrix/power.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "power#1fb3cb5e732f/ansi_on", - "reason": "SELECT power(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "power#1fb3cb5e732f/ansi_off", - "reason": "SELECT power(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "power#50aa498e03a3/ansi_on", "reason": "SELECT power(2, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "power#58436b99c0b7/ansi_off", "reason": "SELECT power(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "power#768810ae773a/ansi_on", - "reason": "SELECT power(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "power#768810ae773a/ansi_off", - "reason": "SELECT power(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "power#7fde02c80370/ansi_on", "reason": "SELECT power(named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/quarter.json b/tests/fixtures/analysis/registry-matrix/quarter.json index 3bd2b4de2..34c539919 100644 --- a/tests/fixtures/analysis/registry-matrix/quarter.json +++ b/tests/fixtures/analysis/registry-matrix/quarter.json @@ -31,14 +31,6 @@ { "id": "quarter#7e5e4bb0baa2/ansi_off", "reason": "SELECT quarter(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "quarter#9e53c8e4594f/ansi_on", - "reason": "SELECT quarter(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "quarter#9e53c8e4594f/ansi_off", - "reason": "SELECT quarter(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/radians.json b/tests/fixtures/analysis/registry-matrix/radians.json index 41971e1e4..9c42eccdd 100644 --- a/tests/fixtures/analysis/registry-matrix/radians.json +++ b/tests/fixtures/analysis/registry-matrix/radians.json @@ -8,14 +8,6 @@ "id": "radians#3eb311f55f31/ansi_off", "reason": "SELECT radians(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "radians#595d7d8afe29/ansi_on", - "reason": "SELECT radians(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "radians#595d7d8afe29/ansi_off", - "reason": "SELECT radians(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "radians#a6b560943a35/ansi_on", "reason": "SELECT radians(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/raise_error.json b/tests/fixtures/analysis/registry-matrix/raise_error.json index 3884cbedf..3c0ca5494 100644 --- a/tests/fixtures/analysis/registry-matrix/raise_error.json +++ b/tests/fixtures/analysis/registry-matrix/raise_error.json @@ -16,14 +16,6 @@ "id": "raise_error#30a64ebeeb6a/ansi_off", "reason": "SELECT raise_error(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "raise_error#5d4434d2c075/ansi_on", - "reason": "SELECT raise_error(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "raise_error#5d4434d2c075/ansi_off", - "reason": "SELECT raise_error(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "raise_error#7316fcbbf706/ansi_on", "reason": "SELECT raise_error(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/regexp.json b/tests/fixtures/analysis/registry-matrix/regexp.json index 96668b9ee..134b0b395 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp.json +++ b/tests/fixtures/analysis/registry-matrix/regexp.json @@ -48,14 +48,6 @@ "id": "regexp#7a9373d75338/ansi_off", "reason": "SELECT regexp('%SystemDrive%\\Users\\John', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp#7e85a4423a0c/ansi_on", - "reason": "SELECT regexp(array(1, 2), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp#7e85a4423a0c/ansi_off", - "reason": "SELECT regexp(array(1, 2), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp#8f7b1c130176/ansi_on", "reason": "SELECT regexp('%SystemDrive%\\Users\\John', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +56,6 @@ "id": "regexp#8f7b1c130176/ansi_off", "reason": "SELECT regexp('%SystemDrive%\\Users\\John', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp#b5e72f23ba3a/ansi_on", - "reason": "SELECT regexp('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp#b5e72f23ba3a/ansi_off", - "reason": "SELECT regexp('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp#f2d787a50f4c/ansi_on", "reason": "SELECT regexp(map('a', 1), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/regexp_count.json b/tests/fixtures/analysis/registry-matrix/regexp_count.json index dd1b0f19f..d4d163c5e 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_count.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_count.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "regexp_count#07bc658c7105/ansi_on", - "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_count#07bc658c7105/ansi_off", - "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_count#0afc8da34f72/ansi_on", "reason": "SELECT regexp_count(map('a', 1), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,6 @@ "id": "regexp_count#5d692adb9c66/ansi_off", "reason": "SELECT regexp_count(named_struct('a', 1, 'b', 'x'), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_count#cdb52bc0b466/ansi_on", - "reason": "SELECT regexp_count(array(1, 2), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_count#cdb52bc0b466/ansi_off", - "reason": "SELECT regexp_count(array(1, 2), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_count#e50fca3b8f7b/ansi_on", "reason": "SELECT regexp_count('Steven Jones and Stephen Smith are the best players', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/regexp_extract.json b/tests/fixtures/analysis/registry-matrix/regexp_extract.json index 4a5e59875..5d14074e7 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_extract.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_extract.json @@ -40,14 +40,6 @@ "id": "regexp_extract#41eb55972574/ansi_off", "reason": "SELECT regexp_extract('100-200', INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "regexp_extract#41ef0cdd8f83/ansi_on", - "reason": "SELECT regexp_extract('100-200', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_extract#41ef0cdd8f83/ansi_off", - "reason": "SELECT regexp_extract('100-200', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_extract#4d31ef6296af/ansi_on", "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,6 @@ "id": "regexp_extract#4d31ef6296af/ansi_off", "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_extract#74bd57081b89/ansi_on", - "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_extract#74bd57081b89/ansi_off", - "reason": "SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_extract#79c755b3b667/ansi_on", "reason": "SELECT regexp_extract(named_struct('a', 1, 'b', 'x'), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -111,14 +95,6 @@ { "id": "regexp_extract#e4b7e0aa5c1b/ansi_off", "reason": "SELECT regexp_extract(map('a', 1), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_extract#fdd1523dc79a/ansi_on", - "reason": "SELECT regexp_extract(array(1, 2), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_extract#fdd1523dc79a/ansi_off", - "reason": "SELECT regexp_extract(array(1, 2), '(\\\\d+)-(\\\\d+)', 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/regexp_instr.json b/tests/fixtures/analysis/registry-matrix/regexp_instr.json index 2407efb9a..649d74e5b 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_instr.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_instr.json @@ -56,14 +56,6 @@ "id": "regexp_instr#a177fdc18858/ansi_off", "reason": "SELECT regexp_instr(map('a', 1), r\"^\\\\abc$\") | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_instr#d1b7ae971b09/ansi_on", - "reason": "SELECT regexp_instr(r\"\\abc\", array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_instr#d1b7ae971b09/ansi_off", - "reason": "SELECT regexp_instr(r\"\\abc\", array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_instr#e495063cde68/ansi_on", "reason": "SELECT regexp_instr(r\"\\abc\", INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -71,14 +63,6 @@ { "id": "regexp_instr#e495063cde68/ansi_off", "reason": "SELECT regexp_instr(r\"\\abc\", INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "regexp_instr#eb546ff0ffa5/ansi_on", - "reason": "SELECT regexp_instr(array(1, 2), r\"^\\\\abc$\") | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_instr#eb546ff0ffa5/ansi_off", - "reason": "SELECT regexp_instr(array(1, 2), r\"^\\\\abc$\") | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/regexp_like.json b/tests/fixtures/analysis/registry-matrix/regexp_like.json index e13eba818..3eca62486 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_like.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_like.json @@ -32,14 +32,6 @@ "id": "regexp_like#84a661eb1231/ansi_off", "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_like#890c550d2cad/ansi_on", - "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_like#890c550d2cad/ansi_off", - "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_like#8ed857c04e18/ansi_on", "reason": "SELECT regexp_like(map('a', 1), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -71,14 +63,6 @@ { "id": "regexp_like#e155c6f9762d/ansi_off", "reason": "SELECT regexp_like('%SystemDrive%\\Users\\John', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "regexp_like#f002c215b8c3/ansi_on", - "reason": "SELECT regexp_like(array(1, 2), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_like#f002c215b8c3/ansi_off", - "reason": "SELECT regexp_like(array(1, 2), '%SystemDrive%\\\\Users.*') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/regexp_replace.json b/tests/fixtures/analysis/registry-matrix/regexp_replace.json index f14359da6..43d05edc2 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_replace.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_replace.json @@ -48,14 +48,6 @@ "id": "regexp_replace#4554f98913c4/ansi_off", "reason": "SELECT regexp_replace('100-200', map('a', 1), 'num') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_replace#4e808b6ab3ea/ansi_on", - "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_replace#4e808b6ab3ea/ansi_off", - "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_replace#69a3284260d7/ansi_on", "reason": "SELECT regexp_replace(named_struct('a', 1, 'b', 'x'), '(\\\\d+)', 'num') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -72,14 +64,6 @@ "id": "regexp_replace#77d4f4ba5844/ansi_off", "reason": "SELECT regexp_replace('100-200', named_struct('a', 1, 'b', 'x'), 'num') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "regexp_replace#790472f65a6c/ansi_on", - "reason": "SELECT regexp_replace('100-200', array(1, 2), 'num') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_replace#790472f65a6c/ansi_off", - "reason": "SELECT regexp_replace('100-200', array(1, 2), 'num') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_replace#7e9104eeb35d/ansi_on", "reason": "SELECT regexp_replace('100-200', '(\\\\d+)', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -111,14 +95,6 @@ { "id": "regexp_replace#fb02919091af/ansi_off", "reason": "SELECT regexp_replace(INTERVAL '1-2' YEAR TO MONTH, '(\\\\d+)', 'num') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "regexp_replace#fb71844662a3/ansi_on", - "reason": "SELECT regexp_replace(array(1, 2), '(\\\\d+)', 'num') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_replace#fb71844662a3/ansi_off", - "reason": "SELECT regexp_replace(array(1, 2), '(\\\\d+)', 'num') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/regexp_substr.json b/tests/fixtures/analysis/registry-matrix/regexp_substr.json index e89fd3cc2..18ff6b727 100644 --- a/tests/fixtures/analysis/registry-matrix/regexp_substr.json +++ b/tests/fixtures/analysis/registry-matrix/regexp_substr.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "regexp_substr#057311aea945/ansi_on", - "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_substr#057311aea945/ansi_off", - "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_substr#5cb59df0f0ef/ansi_on", "reason": "SELECT regexp_substr(INTERVAL '1-2' YEAR TO MONTH, 'Ste(v|ph)en') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -48,14 +40,6 @@ "id": "regexp_substr#892ffdc712e7/ansi_off", "reason": "SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "regexp_substr#97d5b3fe669b/ansi_on", - "reason": "SELECT regexp_substr(array(1, 2), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "regexp_substr#97d5b3fe669b/ansi_off", - "reason": "SELECT regexp_substr(array(1, 2), 'Ste(v|ph)en') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "regexp_substr#a3caad2c31af/ansi_on", "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" diff --git a/tests/fixtures/analysis/registry-matrix/replace.json b/tests/fixtures/analysis/registry-matrix/replace.json index 676d2d46b..35da8e813 100644 --- a/tests/fixtures/analysis/registry-matrix/replace.json +++ b/tests/fixtures/analysis/registry-matrix/replace.json @@ -16,14 +16,6 @@ "id": "replace#1ead83cf0d2e/ansi_off", "reason": "SELECT replace('ABCabc', 'abc', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "replace#45892c6e41c2/ansi_on", - "reason": "SELECT replace('ABCabc', array(1, 2), 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "replace#45892c6e41c2/ansi_off", - "reason": "SELECT replace('ABCabc', array(1, 2), 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "replace#5c277e88fd2d/ansi_on", "reason": "SELECT replace('ABCabc', 'abc', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -40,14 +32,6 @@ "id": "replace#773d4608b460/ansi_off", "reason": "SELECT replace('ABCabc', 'abc', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "replace#7994c08a31a3/ansi_on", - "reason": "SELECT replace(array(1, 2), 'abc', 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "replace#7994c08a31a3/ansi_off", - "reason": "SELECT replace(array(1, 2), 'abc', 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "replace#8abe9653048f/ansi_on", "reason": "SELECT replace('ABCabc', INTERVAL '1 02:03:04' DAY TO SECOND, 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -80,14 +64,6 @@ "id": "replace#bc3da4b48ee0/ansi_off", "reason": "SELECT replace(INTERVAL '1 02:03:04' DAY TO SECOND, 'abc', 'DEF') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "replace#bf27e8ab957c/ansi_on", - "reason": "SELECT replace('ABCabc', 'abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "replace#bf27e8ab957c/ansi_off", - "reason": "SELECT replace('ABCabc', 'abc', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "replace#d9f91490acc7/ansi_on", "reason": "SELECT replace('ABCabc', map('a', 1), 'DEF') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/rint.json b/tests/fixtures/analysis/registry-matrix/rint.json index ee85635cd..4211b7ee1 100644 --- a/tests/fixtures/analysis/registry-matrix/rint.json +++ b/tests/fixtures/analysis/registry-matrix/rint.json @@ -8,14 +8,6 @@ "id": "rint#42fe39692440/ansi_off", "reason": "SELECT rint(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "rint#7531928e97b1/ansi_on", - "reason": "SELECT rint(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rint#7531928e97b1/ansi_off", - "reason": "SELECT rint(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "rint#baeea376e1af/ansi_on", "reason": "SELECT rint(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/round.json b/tests/fixtures/analysis/registry-matrix/round.json index 21c0a9026..87987bbc5 100644 --- a/tests/fixtures/analysis/registry-matrix/round.json +++ b/tests/fixtures/analysis/registry-matrix/round.json @@ -8,14 +8,6 @@ "id": "round#1420a7a45230/ansi_off", "reason": "SELECT round(2.5, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "round#1e8de844e85f/ansi_on", - "reason": "SELECT round(2.5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "round#1e8de844e85f/ansi_off", - "reason": "SELECT round(2.5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "round#286ac35a7044/ansi_on", "reason": "SELECT round(2.5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -71,14 +63,6 @@ { "id": "round#efef4a884ef2/ansi_off", "reason": "SELECT round(map('a', 1), 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "round#f890b98f5266/ansi_on", - "reason": "SELECT round(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "round#f890b98f5266/ansi_off", - "reason": "SELECT round(array(1, 2), 0) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/rpad.json b/tests/fixtures/analysis/registry-matrix/rpad.json index d3ee085c0..41fef2d48 100644 --- a/tests/fixtures/analysis/registry-matrix/rpad.json +++ b/tests/fixtures/analysis/registry-matrix/rpad.json @@ -8,14 +8,6 @@ "id": "rpad#01185a535503/ansi_off", "reason": "SELECT rpad('hi', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "rpad#06a27aefc3e8/ansi_on", - "reason": "SELECT rpad('hi', array(1, 2), '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rpad#06a27aefc3e8/ansi_off", - "reason": "SELECT rpad('hi', array(1, 2), '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "rpad#0aa877274e17/ansi_on", "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" @@ -64,22 +56,6 @@ "id": "rpad#2df795636485/ansi_off", "reason": "SELECT rpad('hi', 5, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "rpad#34af1695c2fb/ansi_on", - "reason": "SELECT rpad(array(1, 2), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rpad#34af1695c2fb/ansi_off", - "reason": "SELECT rpad(array(1, 2), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rpad#4b9f09ad06a5/ansi_on", - "reason": "SELECT rpad('hi', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rpad#4b9f09ad06a5/ansi_off", - "reason": "SELECT rpad('hi', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "rpad#6948ac2f6fa7/ansi_on", "reason": "SELECT rpad(named_struct('a', 1, 'b', 'x'), 5) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -152,14 +128,6 @@ "id": "rpad#c2dc63c23dd1/ansi_off", "reason": "SELECT rpad('hi', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "rpad#c36fcf5d02d6/ansi_on", - "reason": "SELECT rpad(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rpad#c36fcf5d02d6/ansi_off", - "reason": "SELECT rpad(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "rpad#d8ee019cf6cd/ansi_on", "reason": "SELECT rpad('hi', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -176,14 +144,6 @@ "id": "rpad#e1759fee6985/ansi_off", "reason": "SELECT rpad(named_struct('a', 1, 'b', 'x'), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "rpad#e70e9a4e3801/ansi_on", - "reason": "SELECT rpad('hi', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rpad#e70e9a4e3801/ansi_off", - "reason": "SELECT rpad('hi', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "rpad#f3cf473e2510/ansi_on", "reason": "SELECT rpad(map('a', 1), 5, '??') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/rtrim.json b/tests/fixtures/analysis/registry-matrix/rtrim.json index ea0ba67c2..be2b5af09 100644 --- a/tests/fixtures/analysis/registry-matrix/rtrim.json +++ b/tests/fixtures/analysis/registry-matrix/rtrim.json @@ -8,14 +8,6 @@ "id": "rtrim#1737a0f2a2dc/ansi_off", "reason": "SELECT rtrim(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "rtrim#414ec50a8836/ansi_on", - "reason": "SELECT rtrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rtrim#414ec50a8836/ansi_off", - "reason": "SELECT rtrim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "rtrim#4f1bf1caadb5/ansi_on", "reason": "SELECT rtrim(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sec.json b/tests/fixtures/analysis/registry-matrix/sec.json index f29c5652f..7d43bfdfa 100644 --- a/tests/fixtures/analysis/registry-matrix/sec.json +++ b/tests/fixtures/analysis/registry-matrix/sec.json @@ -31,14 +31,6 @@ { "id": "sec#c2e9bb28ade3/ansi_off", "reason": "SELECT sec(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sec#faa27900f220/ansi_on", - "reason": "SELECT sec(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sec#faa27900f220/ansi_off", - "reason": "SELECT sec(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/second.json b/tests/fixtures/analysis/registry-matrix/second.json index 350ab2f27..d0127664f 100644 --- a/tests/fixtures/analysis/registry-matrix/second.json +++ b/tests/fixtures/analysis/registry-matrix/second.json @@ -32,14 +32,6 @@ "id": "second#ade2ed5d7b44/ansi_off", "reason": "SELECT second(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "second#b6eb034a6cc6/ansi_on", - "reason": "SELECT second(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "second#b6eb034a6cc6/ansi_off", - "reason": "SELECT second(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "second#edf06afe63c6/ansi_on", "reason": "SELECT second(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sha.json b/tests/fixtures/analysis/registry-matrix/sha.json index 469749024..1703247fd 100644 --- a/tests/fixtures/analysis/registry-matrix/sha.json +++ b/tests/fixtures/analysis/registry-matrix/sha.json @@ -8,14 +8,6 @@ "id": "sha#0948c7b0df37/ansi_off", "reason": "SELECT sha(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sha#2112efaa84c9/ansi_on", - "reason": "SELECT sha(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sha#2112efaa84c9/ansi_off", - "reason": "SELECT sha(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sha#a6b6487665d4/ansi_on", "reason": "SELECT sha(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sha1.json b/tests/fixtures/analysis/registry-matrix/sha1.json index c6ccd880d..1732ca06a 100644 --- a/tests/fixtures/analysis/registry-matrix/sha1.json +++ b/tests/fixtures/analysis/registry-matrix/sha1.json @@ -31,14 +31,6 @@ { "id": "sha1#c4dfb65cb3b0/ansi_off", "reason": "SELECT sha1(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sha1#c90b1625d341/ansi_on", - "reason": "SELECT sha1(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sha1#c90b1625d341/ansi_off", - "reason": "SELECT sha1(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/sha2.json b/tests/fixtures/analysis/registry-matrix/sha2.json index a8eff8707..342a8b0f4 100644 --- a/tests/fixtures/analysis/registry-matrix/sha2.json +++ b/tests/fixtures/analysis/registry-matrix/sha2.json @@ -16,14 +16,6 @@ "id": "sha2#0d551c2bd461/ansi_off", "reason": "SELECT sha2(map('a', 1), 256) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sha2#471a5e7d41fd/ansi_on", - "reason": "SELECT sha2(array(1, 2), 256) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sha2#471a5e7d41fd/ansi_off", - "reason": "SELECT sha2(array(1, 2), 256) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sha2#5e52fda43a4c/ansi_on", "reason": "SELECT sha2('Spark', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "sha2#5e52fda43a4c/ansi_off", "reason": "SELECT sha2('Spark', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sha2#9286f569ccc1/ansi_on", - "reason": "SELECT sha2('Spark', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sha2#9286f569ccc1/ansi_off", - "reason": "SELECT sha2('Spark', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sha2#9a804177f733/ansi_on", "reason": "SELECT sha2('Spark', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/shiftleft.json b/tests/fixtures/analysis/registry-matrix/shiftleft.json index 914829468..cac941fb8 100644 --- a/tests/fixtures/analysis/registry-matrix/shiftleft.json +++ b/tests/fixtures/analysis/registry-matrix/shiftleft.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "shiftleft#028e57cb3126/ansi_on", - "reason": "SELECT shiftleft(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftleft#028e57cb3126/ansi_off", - "reason": "SELECT shiftleft(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "shiftleft#109b5e440103/ansi_on", "reason": "SELECT shiftleft(2, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -24,14 +16,6 @@ "id": "shiftleft#2746189b8521/ansi_off", "reason": "SELECT shiftleft(named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "shiftleft#43daf427dafa/ansi_on", - "reason": "SELECT shiftleft(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftleft#43daf427dafa/ansi_off", - "reason": "SELECT shiftleft(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "shiftleft#75289f56a862/ansi_on", "reason": "SELECT shiftleft(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/shiftright.json b/tests/fixtures/analysis/registry-matrix/shiftright.json index 4302c0052..41ed5ee3b 100644 --- a/tests/fixtures/analysis/registry-matrix/shiftright.json +++ b/tests/fixtures/analysis/registry-matrix/shiftright.json @@ -16,14 +16,6 @@ "id": "shiftright#0c566b72d3fe/ansi_off", "reason": "SELECT shiftright(named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "shiftright#387cad49d8da/ansi_on", - "reason": "SELECT shiftright(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftright#387cad49d8da/ansi_off", - "reason": "SELECT shiftright(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "shiftright#43df86d52cf4/ansi_on", "reason": "SELECT shiftright(4, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +56,6 @@ "id": "shiftright#9d0da0110d86/ansi_off", "reason": "SELECT shiftright(INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "shiftright#a583285fa625/ansi_on", - "reason": "SELECT shiftright(4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftright#a583285fa625/ansi_off", - "reason": "SELECT shiftright(4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "shiftright#b67e2d9bbada/ansi_on", "reason": "SELECT shiftright(4, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json b/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json index 27053ae9c..b0e97d8ad 100644 --- a/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json +++ b/tests/fixtures/analysis/registry-matrix/shiftrightunsigned.json @@ -8,14 +8,6 @@ "id": "shiftrightunsigned#5a87b30b960f/ansi_off", "reason": "SELECT shiftrightunsigned(map('a', 1), 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "shiftrightunsigned#5b6f5e1feb81/ansi_on", - "reason": "SELECT shiftrightunsigned(4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftrightunsigned#5b6f5e1feb81/ansi_off", - "reason": "SELECT shiftrightunsigned(4, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "shiftrightunsigned#9748b962de44/ansi_on", "reason": "SELECT shiftrightunsigned(4, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -24,14 +16,6 @@ "id": "shiftrightunsigned#9748b962de44/ansi_off", "reason": "SELECT shiftrightunsigned(4, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "shiftrightunsigned#9deada350e37/ansi_on", - "reason": "SELECT shiftrightunsigned(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "shiftrightunsigned#9deada350e37/ansi_off", - "reason": "SELECT shiftrightunsigned(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "shiftrightunsigned#a296dcfd561b/ansi_on", "reason": "SELECT shiftrightunsigned(INTERVAL '1 02:03:04' DAY TO SECOND, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sign.json b/tests/fixtures/analysis/registry-matrix/sign.json index ad8834757..617435efc 100644 --- a/tests/fixtures/analysis/registry-matrix/sign.json +++ b/tests/fixtures/analysis/registry-matrix/sign.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "sign#13016f33ae80/ansi_on", - "reason": "SELECT sign(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sign#13016f33ae80/ansi_off", - "reason": "SELECT sign(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sign#13e8c1b20b6e/ansi_on", "reason": "SELECT sign(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/signum.json b/tests/fixtures/analysis/registry-matrix/signum.json index 1c052f469..3167d315a 100644 --- a/tests/fixtures/analysis/registry-matrix/signum.json +++ b/tests/fixtures/analysis/registry-matrix/signum.json @@ -16,14 +16,6 @@ "id": "signum#492e1b60af0f/ansi_off", "reason": "SELECT signum(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "signum#5de30314d52d/ansi_on", - "reason": "SELECT signum(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "signum#5de30314d52d/ansi_off", - "reason": "SELECT signum(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "signum#7c837d354941/ansi_on", "reason": "SELECT signum(INTERVAL -'100' YEAR) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/sin.json b/tests/fixtures/analysis/registry-matrix/sin.json index a94498871..099514871 100644 --- a/tests/fixtures/analysis/registry-matrix/sin.json +++ b/tests/fixtures/analysis/registry-matrix/sin.json @@ -8,14 +8,6 @@ "id": "sin#07aad739ca7b/ansi_off", "reason": "SELECT sin(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sin#30ae963d3d6f/ansi_on", - "reason": "SELECT sin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sin#30ae963d3d6f/ansi_off", - "reason": "SELECT sin(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sin#6de2eba5fd5b/ansi_on", "reason": "SELECT sin(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sinh.json b/tests/fixtures/analysis/registry-matrix/sinh.json index 1fb024940..c6c375b27 100644 --- a/tests/fixtures/analysis/registry-matrix/sinh.json +++ b/tests/fixtures/analysis/registry-matrix/sinh.json @@ -24,14 +24,6 @@ "id": "sinh#91f2a84a0321/ansi_off", "reason": "SELECT sinh(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sinh#a4b246d8f999/ansi_on", - "reason": "SELECT sinh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sinh#a4b246d8f999/ansi_off", - "reason": "SELECT sinh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sinh#feb84311c281/ansi_on", "reason": "SELECT sinh(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/sqrt.json b/tests/fixtures/analysis/registry-matrix/sqrt.json index d32ac1fbd..734d85b67 100644 --- a/tests/fixtures/analysis/registry-matrix/sqrt.json +++ b/tests/fixtures/analysis/registry-matrix/sqrt.json @@ -8,14 +8,6 @@ "id": "sqrt#16036e88e7c1/ansi_off", "reason": "SELECT sqrt(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "sqrt#4396783664f6/ansi_on", - "reason": "SELECT sqrt(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "sqrt#4396783664f6/ansi_off", - "reason": "SELECT sqrt(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "sqrt#4cf0f8ae607a/ansi_on", "reason": "SELECT sqrt(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/startswith.json b/tests/fixtures/analysis/registry-matrix/startswith.json index 75e0ed759..f079f84ee 100644 --- a/tests/fixtures/analysis/registry-matrix/startswith.json +++ b/tests/fixtures/analysis/registry-matrix/startswith.json @@ -32,14 +32,6 @@ "id": "startswith#19b35e358339/ansi_off", "reason": "SELECT startswith(INTERVAL '1-2' YEAR TO MONTH, 'Spark') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "startswith#347720a57a55/ansi_on", - "reason": "SELECT startswith(array(1, 2), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "startswith#347720a57a55/ansi_off", - "reason": "SELECT startswith(array(1, 2), 'Spark') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "startswith#41a1cdde2774/ansi_on", "reason": "SELECT startswith('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -71,14 +63,6 @@ { "id": "startswith#a56ab8af6405/ansi_off", "reason": "SELECT startswith('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "startswith#bf1ab845092b/ansi_on", - "reason": "SELECT startswith('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "startswith#bf1ab845092b/ansi_off", - "reason": "SELECT startswith('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/substr.json b/tests/fixtures/analysis/registry-matrix/substr.json index 70902e1c1..aa54946d0 100644 --- a/tests/fixtures/analysis/registry-matrix/substr.json +++ b/tests/fixtures/analysis/registry-matrix/substr.json @@ -16,14 +16,6 @@ "id": "substr#0d7df6c77a5b/ansi_off", "reason": "SELECT substr(INTERVAL '1 02:03:04' DAY TO SECOND, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "substr#16e9c6ed673b/ansi_on", - "reason": "SELECT substr('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substr#16e9c6ed673b/ansi_off", - "reason": "SELECT substr('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substr#1e76e4332cc3/ansi_on", "reason": "SELECT substr('Spark SQL', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -32,14 +24,6 @@ "id": "substr#1e76e4332cc3/ansi_off", "reason": "SELECT substr('Spark SQL', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substr#1eac62736f36/ansi_on", - "reason": "SELECT substr('Spark SQL', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substr#1eac62736f36/ansi_off", - "reason": "SELECT substr('Spark SQL', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substr#29ec6f65af26/ansi_on", "reason": "SELECT substr('Spark SQL', INTERVAL '1-2' YEAR TO MONTH, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -64,14 +48,6 @@ "id": "substr#4f609ceaa310/ansi_off", "reason": "SELECT substr('Spark SQL', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substr#5098f3bdd376/ansi_on", - "reason": "SELECT substr(array(1, 2), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substr#5098f3bdd376/ansi_off", - "reason": "SELECT substr(array(1, 2), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substr#723f8b45fc39/ansi_on", "reason": "SELECT substr('Spark SQL', map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -144,14 +120,6 @@ "id": "substr#a02122420647/ansi_off", "reason": "SELECT substr('Spark SQL', 5, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substr#b67f2937523e/ansi_on", - "reason": "SELECT substr(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substr#b67f2937523e/ansi_off", - "reason": "SELECT substr(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substr#bd1ebd93204b/ansi_on", "reason": "SELECT substr('Spark SQL', 5, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -184,14 +152,6 @@ "id": "substr#eb55cdf8fbe1/ansi_off", "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" }, - { - "id": "substr#f38c9880f41b/ansi_on", - "reason": "SELECT substr('Spark SQL', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substr#f38c9880f41b/ansi_off", - "reason": "SELECT substr('Spark SQL', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substr#f4b691e3b8ea/ansi_on", "reason": "SELECT substr(INTERVAL '1-2' YEAR TO MONTH, 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/substring.json b/tests/fixtures/analysis/registry-matrix/substring.json index 159ac573a..a96003342 100644 --- a/tests/fixtures/analysis/registry-matrix/substring.json +++ b/tests/fixtures/analysis/registry-matrix/substring.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "substring#031cf9986895/ansi_on", - "reason": "SELECT substring('Spark SQL', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring#031cf9986895/ansi_off", - "reason": "SELECT substring('Spark SQL', 5, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substring#07e5d6cbbf49/ansi_on", "reason": "SELECT substring(encode('Spark SQL', 'utf-8'), 5) | KRISHIV_UNSUPPORTED_FEATURE: function encode" @@ -72,14 +64,6 @@ "id": "substring#3f2624e3879f/ansi_off", "reason": "SELECT substring('Spark SQL', 5, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substring#4bce01c80b91/ansi_on", - "reason": "SELECT substring(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring#4bce01c80b91/ansi_off", - "reason": "SELECT substring(array(1, 2), 5) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substring#525e241ea7f0/ansi_on", "reason": "SELECT substring(INTERVAL '1-2' YEAR TO MONTH, 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -96,14 +80,6 @@ "id": "substring#6372499e9a5a/ansi_off", "reason": "SELECT substring(map('a', 1), 5) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substring#826898b7fd31/ansi_on", - "reason": "SELECT substring(array(1, 2), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring#826898b7fd31/ansi_off", - "reason": "SELECT substring(array(1, 2), 5, 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substring#8b42b0b920a8/ansi_on", "reason": "SELECT substring('Spark SQL', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -120,14 +96,6 @@ "id": "substring#8b6b79a607c1/ansi_off", "reason": "SELECT substring(INTERVAL '1 02:03:04' DAY TO SECOND, 5, 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "substring#95381cdc26f5/ansi_on", - "reason": "SELECT substring('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring#95381cdc26f5/ansi_off", - "reason": "SELECT substring('Spark SQL', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substring#9715e4291ca1/ansi_on", "reason": "SELECT substring(INTERVAL '1 02:03:04' DAY TO SECOND, 5) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -184,14 +152,6 @@ "id": "substring#f4a34829cdcf/ansi_off", "reason": "SELECT substring('Spark SQL', named_struct('a', 1, 'b', 'x'), 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "substring#f51d6ccadba4/ansi_on", - "reason": "SELECT substring('Spark SQL', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "substring#f51d6ccadba4/ansi_off", - "reason": "SELECT substring('Spark SQL', array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "substring#f57800213cc9/ansi_on", "reason": "SELECT substring('Spark SQL', 5, 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/tan.json b/tests/fixtures/analysis/registry-matrix/tan.json index 845e62dc5..adf79fe91 100644 --- a/tests/fixtures/analysis/registry-matrix/tan.json +++ b/tests/fixtures/analysis/registry-matrix/tan.json @@ -31,14 +31,6 @@ { "id": "tan#eef3973d8de1/ansi_off", "reason": "SELECT tan(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "tan#f60468d721a2/ansi_on", - "reason": "SELECT tan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "tan#f60468d721a2/ansi_off", - "reason": "SELECT tan(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/tanh.json b/tests/fixtures/analysis/registry-matrix/tanh.json index 3dc0e2483..4ba6e0bb9 100644 --- a/tests/fixtures/analysis/registry-matrix/tanh.json +++ b/tests/fixtures/analysis/registry-matrix/tanh.json @@ -8,14 +8,6 @@ "id": "tanh#054342254ba1/ansi_off", "reason": "SELECT tanh(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "tanh#bbec36e28d72/ansi_on", - "reason": "SELECT tanh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "tanh#bbec36e28d72/ansi_off", - "reason": "SELECT tanh(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "tanh#bc60aa3cc8fe/ansi_on", "reason": "SELECT tanh(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/to_char.json b/tests/fixtures/analysis/registry-matrix/to_char.json index 4a78c60ce..9b1901281 100644 --- a/tests/fixtures/analysis/registry-matrix/to_char.json +++ b/tests/fixtures/analysis/registry-matrix/to_char.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "to_char#0e6f2a6c98ce/ansi_on", - "reason": "SELECT to_char(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_char#0e6f2a6c98ce/ansi_off", - "reason": "SELECT to_char(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_char#18b01e8066ef/ansi_on", "reason": "SELECT to_char(454, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_DIGIT" @@ -16,14 +8,6 @@ "id": "to_char#18b01e8066ef/ansi_off", "reason": "SELECT to_char(454, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_DIGIT" }, - { - "id": "to_char#62ce9da6957b/ansi_on", - "reason": "SELECT to_char(454, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_char#62ce9da6957b/ansi_off", - "reason": "SELECT to_char(454, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_char#6710535d81b4/ansi_on", "reason": "SELECT to_char(encode('abc', 'utf-8'), 'utf-8') | KRISHIV_UNSUPPORTED_FEATURE: function encode" diff --git a/tests/fixtures/analysis/registry-matrix/to_number.json b/tests/fixtures/analysis/registry-matrix/to_number.json index 70652f70d..1e5b4b0f0 100644 --- a/tests/fixtures/analysis/registry-matrix/to_number.json +++ b/tests/fixtures/analysis/registry-matrix/to_number.json @@ -16,14 +16,6 @@ "id": "to_number#2ac9fb75cd2c/ansi_off", "reason": "SELECT to_number(INTERVAL '1-2' YEAR TO MONTH, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "to_number#672ac52e1b84/ansi_on", - "reason": "SELECT to_number('454', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_number#672ac52e1b84/ansi_off", - "reason": "SELECT to_number('454', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_number#7e6e35712586/ansi_on", "reason": "SELECT to_number('454', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_TOKEN" @@ -48,14 +40,6 @@ "id": "to_number#8876d9595232/ansi_off", "reason": "SELECT to_number('454', named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "to_number#8d4c3a7592dc/ansi_on", - "reason": "SELECT to_number(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_number#8d4c3a7592dc/ansi_off", - "reason": "SELECT to_number(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_number#8e822c2c1477/ansi_on", "reason": "SELECT to_number(INTERVAL '1 02:03:04' DAY TO SECOND, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json b/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json index 8ef11c24c..1ff79531a 100644 --- a/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json +++ b/tests/fixtures/analysis/registry-matrix/to_utc_timestamp.json @@ -32,22 +32,6 @@ "id": "to_utc_timestamp#4007b97e1f30/ansi_off", "reason": "SELECT to_utc_timestamp('2016-08-31', INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "to_utc_timestamp#6e393f2bd812/ansi_on", - "reason": "SELECT to_utc_timestamp(array(1, 2), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_utc_timestamp#6e393f2bd812/ansi_off", - "reason": "SELECT to_utc_timestamp(array(1, 2), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_utc_timestamp#78b01f86bbd7/ansi_on", - "reason": "SELECT to_utc_timestamp('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_utc_timestamp#78b01f86bbd7/ansi_off", - "reason": "SELECT to_utc_timestamp('2016-08-31', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_utc_timestamp#9ec1404ab832/ansi_on", "reason": "SELECT to_utc_timestamp(map('a', 1), 'Asia/Seoul') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/to_varchar.json b/tests/fixtures/analysis/registry-matrix/to_varchar.json index a75f3193d..a6c13cdd0 100644 --- a/tests/fixtures/analysis/registry-matrix/to_varchar.json +++ b/tests/fixtures/analysis/registry-matrix/to_varchar.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "to_varchar#0bac32cbaaef/ansi_on", - "reason": "SELECT to_varchar(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_varchar#0bac32cbaaef/ansi_off", - "reason": "SELECT to_varchar(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_varchar#2197c57b4b5a/ansi_on", "reason": "SELECT to_varchar(named_struct('a', 1, 'b', 'x'), '999') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -80,14 +72,6 @@ "id": "to_varchar#9f23b08b45e0/ansi_off", "reason": "SELECT to_varchar(INTERVAL '1-2' YEAR TO MONTH, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "to_varchar#cce983c75f34/ansi_on", - "reason": "SELECT to_varchar(454, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "to_varchar#cce983c75f34/ansi_off", - "reason": "SELECT to_varchar(454, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "to_varchar#ebf434f037b3/ansi_on", "reason": "SELECT to_varchar(454, map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/transform.json b/tests/fixtures/analysis/registry-matrix/transform.json new file mode 100644 index 000000000..6a253e6cc --- /dev/null +++ b/tests/fixtures/analysis/registry-matrix/transform.json @@ -0,0 +1,38 @@ +{ + "entries": [ + { + "id": "transform#22257e088307/ansi_on", + "reason": "SELECT transform(INTERVAL '1-2' YEAR TO MONTH, x -> x + 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "transform#22257e088307/ansi_off", + "reason": "SELECT transform(INTERVAL '1-2' YEAR TO MONTH, x -> x + 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "transform#49d49cb35e55/ansi_on", + "reason": "SELECT transform(named_struct('a', 1, 'b', 'x'), x -> x + 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "transform#49d49cb35e55/ansi_off", + "reason": "SELECT transform(named_struct('a', 1, 'b', 'x'), x -> x + 1) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "transform#5724275e0d67/ansi_on", + "reason": "SELECT transform(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x + 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "transform#5724275e0d67/ansi_off", + "reason": "SELECT transform(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x + 1) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "transform#5819dd452d8e/ansi_on", + "reason": "SELECT transform(map('a', 1), x -> x + 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + }, + { + "id": "transform#5819dd452d8e/ansi_off", + "reason": "SELECT transform(map('a', 1), x -> x + 1) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" + } + ], + "format_version": 1, + "function": "transform" +} diff --git a/tests/fixtures/analysis/registry-matrix/trim.json b/tests/fixtures/analysis/registry-matrix/trim.json index 188e769e6..42088ba32 100644 --- a/tests/fixtures/analysis/registry-matrix/trim.json +++ b/tests/fixtures/analysis/registry-matrix/trim.json @@ -16,14 +16,6 @@ "id": "trim#eb0fa3d83d97/ansi_off", "reason": "SELECT trim(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "trim#f04e4c7ecbdb/ansi_on", - "reason": "SELECT trim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "trim#f04e4c7ecbdb/ansi_off", - "reason": "SELECT trim(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "trim#f3c2ecedc771/ansi_on", "reason": "SELECT trim(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/trunc.json b/tests/fixtures/analysis/registry-matrix/trunc.json index aa730b8cc..fd64934e3 100644 --- a/tests/fixtures/analysis/registry-matrix/trunc.json +++ b/tests/fixtures/analysis/registry-matrix/trunc.json @@ -16,22 +16,6 @@ "id": "trunc#3f6bf3a87eef/ansi_off", "reason": "SELECT trunc(map('a', 1), 'week') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "trunc#46ec428ec220/ansi_on", - "reason": "SELECT trunc(array(1, 2), 'week') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "trunc#46ec428ec220/ansi_off", - "reason": "SELECT trunc(array(1, 2), 'week') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "trunc#57ac9a2715da/ansi_on", - "reason": "SELECT trunc('2019-08-04', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "trunc#57ac9a2715da/ansi_off", - "reason": "SELECT trunc('2019-08-04', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "trunc#96fb0c7ae0b1/ansi_on", "reason": "SELECT trunc(named_struct('a', 1, 'b', 'x'), 'week') | KRISHIV_UNSUPPORTED_FEATURE: function named_struct 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..640c5ded8 100644 --- a/tests/fixtures/analysis/registry-matrix/try_add.json +++ b/tests/fixtures/analysis/registry-matrix/try_add.json @@ -132,14 +132,6 @@ "id": "try_add#7227d469fb93/ansi_off", "reason": "SELECT try_add(CAST(NULL AS timestamp), interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "try_add#7b854b6fa631/ansi_on", - "reason": "SELECT try_add(1, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_add#7b854b6fa631/ansi_off", - "reason": "SELECT try_add(1, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_add#7d65f7b45439/ansi_on", "reason": "SELECT try_add(1, INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -232,14 +224,6 @@ "id": "try_add#cef78fc236ba/ansi_off", "reason": "SELECT try_add(INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "try_add#d0e88d1d20b6/ansi_on", - "reason": "SELECT try_add(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_add#d0e88d1d20b6/ansi_off", - "reason": "SELECT try_add(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_add#ddadaf94c15e/ansi_on", "reason": "SELECT try_add(CAST(NULL AS interval year), interval 2 year) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")" diff --git a/tests/fixtures/analysis/registry-matrix/try_divide.json b/tests/fixtures/analysis/registry-matrix/try_divide.json index 6438cc3e5..7da5c0fa4 100644 --- a/tests/fixtures/analysis/registry-matrix/try_divide.json +++ b/tests/fixtures/analysis/registry-matrix/try_divide.json @@ -16,14 +16,6 @@ "id": "try_divide#438928ec5060/ansi_off", "reason": "SELECT try_divide(INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "try_divide#57472aca288d/ansi_on", - "reason": "SELECT try_divide(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_divide#57472aca288d/ansi_off", - "reason": "SELECT try_divide(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_divide#5a3a4d187961/ansi_off", "reason": "SELECT try_divide('1', 2) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" @@ -108,14 +100,6 @@ "id": "try_divide#d477c1bee5e3/ansi_off", "reason": "SELECT try_divide(3, '1') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "id": "try_divide#fa21be3af2ec/ansi_on", - "reason": "SELECT try_divide(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_divide#fa21be3af2ec/ansi_off", - "reason": "SELECT try_divide(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_divide#ff290cce7e9e/ansi_off", "reason": "SELECT try_divide('abc', 2) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" diff --git a/tests/fixtures/analysis/registry-matrix/try_mod.json b/tests/fixtures/analysis/registry-matrix/try_mod.json index d773f0e40..c1154ad4d 100644 --- a/tests/fixtures/analysis/registry-matrix/try_mod.json +++ b/tests/fixtures/analysis/registry-matrix/try_mod.json @@ -72,14 +72,6 @@ "id": "try_mod#96321dd79abb/ansi_off", "reason": "SELECT try_mod('1', 2) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "id": "try_mod#b75bbd5e7fae/ansi_on", - "reason": "SELECT try_mod(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_mod#b75bbd5e7fae/ansi_off", - "reason": "SELECT try_mod(3, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_mod#e8377e2c5a5d/ansi_on", "reason": "SELECT try_mod(3, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" @@ -87,14 +79,6 @@ { "id": "try_mod#e8377e2c5a5d/ansi_off", "reason": "SELECT try_mod(3, INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_mod#f62535c1ea84/ansi_on", - "reason": "SELECT try_mod(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_mod#f62535c1ea84/ansi_off", - "reason": "SELECT try_mod(array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/try_multiply.json b/tests/fixtures/analysis/registry-matrix/try_multiply.json index eca90cff9..0e92f5ef4 100644 --- a/tests/fixtures/analysis/registry-matrix/try_multiply.json +++ b/tests/fixtures/analysis/registry-matrix/try_multiply.json @@ -16,14 +16,6 @@ "id": "try_multiply#28dbd7c5a497/ansi_off", "reason": "SELECT try_multiply(2, named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "try_multiply#2a85c0d45242/ansi_on", - "reason": "SELECT try_multiply(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_multiply#2a85c0d45242/ansi_off", - "reason": "SELECT try_multiply(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_multiply#31933e3dbf90/ansi_on", "reason": "SELECT try_multiply(CAST(NULL AS interval year), 3) | parse: KRISHIV_UNSUPPORTED_FEATURE: interval data types (\"INTERVAL\")" @@ -100,14 +92,6 @@ "id": "try_multiply#bb56f48ad04e/ansi_off", "reason": "SELECT try_multiply(named_struct('a', 1, 'b', 'x'), 3) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" }, - { - "id": "try_multiply#c3b02618e954/ansi_on", - "reason": "SELECT try_multiply(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_multiply#c3b02618e954/ansi_off", - "reason": "SELECT try_multiply(array(1, 2), 3) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_multiply#f8aceea556aa/ansi_off", "reason": "SELECT try_multiply('abc', 3) | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" diff --git a/tests/fixtures/analysis/registry-matrix/try_subtract.json b/tests/fixtures/analysis/registry-matrix/try_subtract.json index 898c34fad..19e6a9a96 100644 --- a/tests/fixtures/analysis/registry-matrix/try_subtract.json +++ b/tests/fixtures/analysis/registry-matrix/try_subtract.json @@ -4,14 +4,6 @@ "id": "try_subtract#0edc9301ffa2/ansi_off", "reason": "SELECT try_subtract(2, '1') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "id": "try_subtract#11f4067daafd/ansi_on", - "reason": "SELECT try_subtract(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_subtract#11f4067daafd/ansi_off", - "reason": "SELECT try_subtract(array(1, 2), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_subtract#170516e36186/ansi_on", "reason": "SELECT try_subtract(2, TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: date and timestamp arithmetic where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -156,14 +148,6 @@ "id": "try_subtract#901361175675/ansi_off", "reason": "SELECT try_subtract(2, 'abc') | KRISHIV_UNSUPPORTED_FEATURE: implicit string casts with spark.sql.ansi.enabled off" }, - { - "id": "try_subtract#922f04f83a9d/ansi_on", - "reason": "SELECT try_subtract(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, - { - "id": "try_subtract#922f04f83a9d/ansi_off", - "reason": "SELECT try_subtract(2, array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES" - }, { "id": "try_subtract#a275842dc947/ansi_on", "reason": "SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/try_to_number.json b/tests/fixtures/analysis/registry-matrix/try_to_number.json index 725924c3c..316044827 100644 --- a/tests/fixtures/analysis/registry-matrix/try_to_number.json +++ b/tests/fixtures/analysis/registry-matrix/try_to_number.json @@ -48,14 +48,6 @@ "id": "try_to_number#45bb6eb12996/ansi_off", "reason": "SELECT try_to_number(map('a', 1), '999') | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "try_to_number#69b8cbb7518e/ansi_on", - "reason": "SELECT try_to_number('454', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_to_number#69b8cbb7518e/ansi_off", - "reason": "SELECT try_to_number('454', array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_to_number#77409df43665/ansi_on", "reason": "SELECT try_to_number('454', TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | DATATYPE_MISMATCH.NON_FOLDABLE_INPUT where Spark has INVALID_FORMAT.UNEXPECTED_TOKEN" @@ -72,14 +64,6 @@ "id": "try_to_number#782169bd58ea/ansi_off", "reason": "SELECT try_to_number('454', INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has INVALID_FORMAT.WRONG_NUM_DIGIT" }, - { - "id": "try_to_number#9f910a6cefde/ansi_on", - "reason": "SELECT try_to_number(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "try_to_number#9f910a6cefde/ansi_off", - "reason": "SELECT try_to_number(array(1, 2), '999') | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "try_to_number#b758b382c427/ansi_on", "reason": "SELECT try_to_number(INTERVAL '1 02:03:04' DAY TO SECOND, '999') | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/ucase.json b/tests/fixtures/analysis/registry-matrix/ucase.json index bfb8d688e..eacd410c1 100644 --- a/tests/fixtures/analysis/registry-matrix/ucase.json +++ b/tests/fixtures/analysis/registry-matrix/ucase.json @@ -8,14 +8,6 @@ "id": "ucase#05ac574f466d/ansi_off", "reason": "SELECT ucase(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "ucase#7d9d4bbe7436/ansi_on", - "reason": "SELECT ucase(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "ucase#7d9d4bbe7436/ansi_off", - "reason": "SELECT ucase(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "ucase#9de2d667346e/ansi_on", "reason": "SELECT ucase(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/unix_date.json b/tests/fixtures/analysis/registry-matrix/unix_date.json index a44bdcd7d..0598b2673 100644 --- a/tests/fixtures/analysis/registry-matrix/unix_date.json +++ b/tests/fixtures/analysis/registry-matrix/unix_date.json @@ -39,14 +39,6 @@ { "id": "unix_date#da1a0a925766/ansi_off", "reason": "SELECT unix_date(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "unix_date#e49b5743d3da/ansi_on", - "reason": "SELECT unix_date(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "unix_date#e49b5743d3da/ansi_off", - "reason": "SELECT unix_date(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/upper.json b/tests/fixtures/analysis/registry-matrix/upper.json index 68254113d..69ed0bdd8 100644 --- a/tests/fixtures/analysis/registry-matrix/upper.json +++ b/tests/fixtures/analysis/registry-matrix/upper.json @@ -31,14 +31,6 @@ { "id": "upper#a8ece98a87b6/ansi_off", "reason": "SELECT upper(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "upper#dc8ae8109118/ansi_on", - "reason": "SELECT upper(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "upper#dc8ae8109118/ansi_off", - "reason": "SELECT upper(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/weekday.json b/tests/fixtures/analysis/registry-matrix/weekday.json index 1b31fe52e..3175d8fa4 100644 --- a/tests/fixtures/analysis/registry-matrix/weekday.json +++ b/tests/fixtures/analysis/registry-matrix/weekday.json @@ -16,14 +16,6 @@ "id": "weekday#7ace552f16ce/ansi_off", "reason": "SELECT weekday(named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "weekday#9569b8dd944c/ansi_on", - "reason": "SELECT weekday(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "weekday#9569b8dd944c/ansi_off", - "reason": "SELECT weekday(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "weekday#a8e54d4f1e7a/ansi_on", "reason": "SELECT weekday(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/weekofyear.json b/tests/fixtures/analysis/registry-matrix/weekofyear.json index 83cc2b2e9..6bfb6185a 100644 --- a/tests/fixtures/analysis/registry-matrix/weekofyear.json +++ b/tests/fixtures/analysis/registry-matrix/weekofyear.json @@ -31,14 +31,6 @@ { "id": "weekofyear#bae528dc4232/ansi_off", "reason": "SELECT weekofyear(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "weekofyear#cde71a2a9453/ansi_on", - "reason": "SELECT weekofyear(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "weekofyear#cde71a2a9453/ansi_off", - "reason": "SELECT weekofyear(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/xxhash64.json b/tests/fixtures/analysis/registry-matrix/xxhash64.json index ef3a4b91a..2946a666b 100644 --- a/tests/fixtures/analysis/registry-matrix/xxhash64.json +++ b/tests/fixtures/analysis/registry-matrix/xxhash64.json @@ -1,45 +1,5 @@ { "entries": [ - { - "id": "xxhash64#04d801e25e35/ansi_on", - "reason": "SELECT xxhash64(CAST(NULL AS string), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#04d801e25e35/ansi_off", - "reason": "SELECT xxhash64(CAST(NULL AS string), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#095784466712/ansi_on", - "reason": "SELECT xxhash64(1.5D, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#095784466712/ansi_off", - "reason": "SELECT xxhash64(1.5D, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#13b30bbffb5a/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), CAST(1 AS TINYINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#13b30bbffb5a/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), CAST(1 AS TINYINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#1446772cdb17/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS DECIMAL(38,18))) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#1446772cdb17/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS DECIMAL(38,18))) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#178bee7fcf10/ansi_on", - "reason": "SELECT xxhash64(CAST(1.5 AS FLOAT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#178bee7fcf10/ansi_off", - "reason": "SELECT xxhash64(CAST(1.5 AS FLOAT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "xxhash64#1799a60ab0d0/ansi_on", "reason": "SELECT xxhash64('Spark', named_struct('a', 1, 'b', 'x'), 2) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" @@ -48,22 +8,6 @@ "id": "xxhash64#1799a60ab0d0/ansi_off", "reason": "SELECT xxhash64('Spark', named_struct('a', 1, 'b', 'x'), 2) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" }, - { - "id": "xxhash64#1c0a6e612b22/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#1c0a6e612b22/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#262bbf2d0fc5/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#262bbf2d0fc5/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "xxhash64#27bf617616cb/ansi_on", "reason": "SELECT xxhash64('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" @@ -72,29 +16,13 @@ "id": "xxhash64#27bf617616cb/ansi_off", "reason": "SELECT xxhash64('Spark', map('a', 1), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, - { - "id": "xxhash64#2c84929b4420/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#2c84929b4420/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), 1) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "xxhash64#30b81390e09c/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" + "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "xxhash64#30b81390e09c/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" - }, - { - "id": "xxhash64#349ac41dfb58/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#349ac41dfb58/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), '1') | KRISHIV_UNSUPPORTED_FEATURE: function array" + "reason": "SELECT xxhash64('Spark', array(123), map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, { "id": "xxhash64#36cc90cab019/ansi_on", @@ -104,30 +32,6 @@ "id": "xxhash64#36cc90cab019/ansi_off", "reason": "SELECT xxhash64('Spark', array(123), INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "xxhash64#3ca12993a520/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#3ca12993a520/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), TIMESTAMP_NTZ'2024-02-29 12:34:56.123456') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#3ebf8dfbd92e/ansi_on", - "reason": "SELECT xxhash64(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#3ebf8dfbd92e/ansi_off", - "reason": "SELECT xxhash64(TIMESTAMP'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#3ed299546ff7/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), DATE'2024-02-29') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#3ed299546ff7/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), DATE'2024-02-29') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "xxhash64#46bae09a5a04/ansi_on", "reason": "SELECT xxhash64(INTERVAL '1-2' YEAR TO MONTH, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -136,117 +40,13 @@ "id": "xxhash64#46bae09a5a04/ansi_off", "reason": "SELECT xxhash64(INTERVAL '1-2' YEAR TO MONTH, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "xxhash64#4de68e47e367/ansi_on", - "reason": "SELECT xxhash64('', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#4de68e47e367/ansi_off", - "reason": "SELECT xxhash64('', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#5b1bb149749b/ansi_on", - "reason": "SELECT xxhash64(1, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#5b1bb149749b/ansi_off", - "reason": "SELECT xxhash64(1, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#5f7f062051c0/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#5f7f062051c0/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#6175a87d7b79/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), CAST(2147483647 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#6175a87d7b79/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), CAST(2147483647 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#69b363904109/ansi_on", - "reason": "SELECT xxhash64('1', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#69b363904109/ansi_off", - "reason": "SELECT xxhash64('1', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#6c0515f68f16/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), 1L) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#6c0515f68f16/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), 1L) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#6c344a698829/ansi_on", - "reason": "SELECT xxhash64(CAST(1.5 AS DECIMAL(10,2)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#6c344a698829/ansi_off", - "reason": "SELECT xxhash64(CAST(1.5 AS DECIMAL(10,2)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "xxhash64#6c62c17e8044/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function array" + "reason": "SELECT xxhash64('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" }, { "id": "xxhash64#6c62c17e8044/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#7146dfbaadba/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), 1.5D) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#7146dfbaadba/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), 1.5D) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#7a3e36bf27da/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS DECIMAL(10,2))) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#7a3e36bf27da/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS DECIMAL(10,2))) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#7f651b551773/ansi_on", - "reason": "SELECT xxhash64('abc', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#7f651b551773/ansi_off", - "reason": "SELECT xxhash64('abc', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#7fb8bab3c253/ansi_on", - "reason": "SELECT xxhash64(1L, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#7fb8bab3c253/ansi_off", - "reason": "SELECT xxhash64(1L, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#7fc5a11f73c0/ansi_on", - "reason": "SELECT xxhash64(' \\t a\\u3000\\n ', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#7fc5a11f73c0/ansi_off", - "reason": "SELECT xxhash64(' \\t a\\u3000\\n ', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#88be02abdc0a/ansi_on", - "reason": "SELECT xxhash64('Spark', CAST(array() AS array), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#88be02abdc0a/ansi_off", - "reason": "SELECT xxhash64('Spark', CAST(array() AS array), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" + "reason": "SELECT xxhash64('Spark', array(123), named_struct('a', 1, 'b', 'x')) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" }, { "id": "xxhash64#89b3d078d407/ansi_on", @@ -256,30 +56,6 @@ "id": "xxhash64#89b3d078d407/ansi_off", "reason": "SELECT xxhash64('Spark', INTERVAL '1-2' YEAR TO MONTH, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "xxhash64#900c868e26bb/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), CAST(NULL AS int)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#900c868e26bb/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), CAST(NULL AS int)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#a3f82a9411a5/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), X'01') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#a3f82a9411a5/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), X'01') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#a4386f4089b0/ansi_on", - "reason": "SELECT xxhash64(NULL, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#a4386f4089b0/ansi_off", - "reason": "SELECT xxhash64(NULL, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "xxhash64#aa4cafed551d/ansi_on", "reason": "SELECT xxhash64('Spark', INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -288,94 +64,6 @@ "id": "xxhash64#aa4cafed551d/ansi_off", "reason": "SELECT xxhash64('Spark', INTERVAL '1 02:03:04' DAY TO SECOND, 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "xxhash64#b8b7ba805159/ansi_on", - "reason": "SELECT xxhash64(CAST(1 AS TINYINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#b8b7ba805159/ansi_off", - "reason": "SELECT xxhash64(CAST(1 AS TINYINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#c1bdc4c0e4da/ansi_on", - "reason": "SELECT xxhash64(CAST(1 AS SMALLINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#c1bdc4c0e4da/ansi_off", - "reason": "SELECT xxhash64(CAST(1 AS SMALLINT), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#c46cdfcda1d4/ansi_on", - "reason": "SELECT xxhash64(CAST(1.5 AS DECIMAL(38,18)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#c46cdfcda1d4/ansi_off", - "reason": "SELECT xxhash64(CAST(1.5 AS DECIMAL(38,18)), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#c4f7bcbebdee/ansi_on", - "reason": "SELECT xxhash64('Ä€日本語😀é', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#c4f7bcbebdee/ansi_off", - "reason": "SELECT xxhash64('Ä€日本語😀é', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#c695d37e19e8/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), CAST(1 AS SMALLINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#c695d37e19e8/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), CAST(1 AS SMALLINT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#c9a780cf156a/ansi_on", - "reason": "SELECT xxhash64('Spark', CAST(array(NULL) AS array), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#c9a780cf156a/ansi_off", - "reason": "SELECT xxhash64('Spark', CAST(array(NULL) AS array), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#d38029db62a8/ansi_on", - "reason": "SELECT xxhash64('Spark', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#d38029db62a8/ansi_off", - "reason": "SELECT xxhash64('Spark', array(1, 2), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#d90fd88f99d5/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), CAST(-2147483648 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#d90fd88f99d5/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), CAST(-2147483648 AS INT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#da904e59abfa/ansi_on", - "reason": "SELECT xxhash64(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#da904e59abfa/ansi_off", - "reason": "SELECT xxhash64(TIMESTAMP_NTZ'2024-02-29 12:34:56.123456', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#dd7cffaf7f2d/ansi_on", - "reason": "SELECT xxhash64(DATE'2024-02-29', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#dd7cffaf7f2d/ansi_off", - "reason": "SELECT xxhash64(DATE'2024-02-29', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#e03cf1df4795/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), 'abc') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#e03cf1df4795/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), 'abc') | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "xxhash64#e69ca7f985b4/ansi_on", "reason": "SELECT xxhash64('Spark', array(123), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -384,30 +72,6 @@ "id": "xxhash64#e69ca7f985b4/ansi_off", "reason": "SELECT xxhash64('Spark', array(123), INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "xxhash64#e988f0567582/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#e988f0567582/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), NULL) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#ed4eed24ba64/ansi_on", - "reason": "SELECT xxhash64(true, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#ed4eed24ba64/ansi_off", - "reason": "SELECT xxhash64(true, array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#ee8d57c192df/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS FLOAT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#ee8d57c192df/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), CAST(1.5 AS FLOAT)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "xxhash64#eea7d24d6cde/ansi_on", "reason": "SELECT xxhash64(named_struct('a', 1, 'b', 'x'), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" @@ -416,22 +80,6 @@ "id": "xxhash64#eea7d24d6cde/ansi_off", "reason": "SELECT xxhash64(named_struct('a', 1, 'b', 'x'), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct" }, - { - "id": "xxhash64#f20293a2a3c7/ansi_on", - "reason": "SELECT xxhash64(X'01', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#f20293a2a3c7/ansi_off", - "reason": "SELECT xxhash64(X'01', array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#f37dcdf02cd4/ansi_on", - "reason": "SELECT xxhash64('Spark', array(123), true) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#f37dcdf02cd4/ansi_off", - "reason": "SELECT xxhash64('Spark', array(123), true) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "xxhash64#f5d3d559ad3a/ansi_on", "reason": "SELECT xxhash64(map('a', 1), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" @@ -440,14 +88,6 @@ "id": "xxhash64#f5d3d559ad3a/ansi_off", "reason": "SELECT xxhash64(map('a', 1), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.HASH_MAP_TYPE" }, - { - "id": "xxhash64#f79d45019309/ansi_on", - "reason": "SELECT xxhash64(CAST(X'C328FF' AS STRING), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#f79d45019309/ansi_off", - "reason": "SELECT xxhash64(CAST(X'C328FF' AS STRING), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "xxhash64#f916e9e6b8e7/ansi_on", "reason": "SELECT xxhash64(INTERVAL '1 02:03:04' DAY TO SECOND, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" @@ -455,14 +95,6 @@ { "id": "xxhash64#f916e9e6b8e7/ansi_off", "reason": "SELECT xxhash64(INTERVAL '1 02:03:04' DAY TO SECOND, array(123), 2) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" - }, - { - "id": "xxhash64#fb104518ccd7/ansi_on", - "reason": "SELECT xxhash64(array(1, 2), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "xxhash64#fb104518ccd7/ansi_off", - "reason": "SELECT xxhash64(array(1, 2), array(123), 2) | KRISHIV_UNSUPPORTED_FEATURE: function array" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/year.json b/tests/fixtures/analysis/registry-matrix/year.json index 3f77c839a..e90da3011 100644 --- a/tests/fixtures/analysis/registry-matrix/year.json +++ b/tests/fixtures/analysis/registry-matrix/year.json @@ -16,14 +16,6 @@ "id": "year#64d0616f8b51/ansi_off", "reason": "SELECT year(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "year#98b02509736a/ansi_on", - "reason": "SELECT year(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "year#98b02509736a/ansi_off", - "reason": "SELECT year(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "year#c5aacd8222e2/ansi_on", "reason": "SELECT year(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/zeroifnull.json b/tests/fixtures/analysis/registry-matrix/zeroifnull.json index 325ca60cb..5f55678c5 100644 --- a/tests/fixtures/analysis/registry-matrix/zeroifnull.json +++ b/tests/fixtures/analysis/registry-matrix/zeroifnull.json @@ -16,14 +16,6 @@ "id": "zeroifnull#525de99a30fd/ansi_off", "reason": "SELECT zeroifnull(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" }, - { - "id": "zeroifnull#5369bb95092d/ansi_on", - "reason": "SELECT zeroifnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, - { - "id": "zeroifnull#5369bb95092d/ansi_off", - "reason": "SELECT zeroifnull(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" - }, { "id": "zeroifnull#583a6c570fa6/ansi_on", "reason": "SELECT zeroifnull(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.DATA_DIFF_TYPES" diff --git a/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json b/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json index 279bb83c6..15ec1ed2f 100644 --- a/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json +++ b/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json @@ -2,75 +2,75 @@ "entries": [ { "query": "SELECT map_zip_with(array_map1, array_map2, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(decimal_map1, decimal_map2, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(decimal_map1, double_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(decimal_map1, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(decimal_map1, string_map4, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(decimal_map2, double_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(decimal_map2, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(double_map, float_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(float_infinity_map1, float_infinity_map2, (k, v1, v2) -> (v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(float_nan_map1, float_nan_map2, (k, v1, v2) -> (v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(float_zero_map, float_neg_zero_map, (k, v1, v2) -> (v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(int_map, bigint_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(smallint_map, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(string_map1, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(string_map2, date_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(struct_map1, struct_map2, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(timestamp_map, string_map3, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" }, { "query": "SELECT map_zip_with(tinyint_map, smallint_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: lambda functions" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" } ], "file": "typeCoercion/native/mapZipWith", diff --git a/tests/spark-golden/known-failures-cases/array.json b/tests/spark-golden/known-failures-cases/array.json index 137aa2112..23234141a 100644 --- a/tests/spark-golden/known-failures-cases/array.json +++ b/tests/spark-golden/known-failures-cases/array.json @@ -1,7 +1,6 @@ { "cases": { "depends-on-command": [ - 1, 2, 3, 5, @@ -95,7 +94,6 @@ 62 ], "sql-commands": [ - 0, 4 ] }, diff --git a/tests/spark-golden/known-failures-cases/except-all.json b/tests/spark-golden/known-failures-cases/except-all.json deleted file mode 100644 index 21c292031..000000000 --- a/tests/spark-golden/known-failures-cases/except-all.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "cases": { - "depends-on-command": [ - 10 - ] - }, - "file": "except-all", - "format_version": 1 -} diff --git a/tests/spark-golden/known-failures-cases/group-by-all-mosha.json b/tests/spark-golden/known-failures-cases/group-by-all-mosha.json index bacb9cb20..947d7ad6f 100644 --- a/tests/spark-golden/known-failures-cases/group-by-all-mosha.json +++ b/tests/spark-golden/known-failures-cases/group-by-all-mosha.json @@ -1,19 +1,7 @@ { "cases": { "depends-on-command": [ - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10 - ], - "sql-commands": [ - 0 + 4 ] }, "file": "group-by-all-mosha", diff --git a/tests/spark-golden/known-failures-cases/having.json b/tests/spark-golden/known-failures-cases/having.json index c2d5de2c4..34ae3e1c0 100644 --- a/tests/spark-golden/known-failures-cases/having.json +++ b/tests/spark-golden/known-failures-cases/having.json @@ -1,7 +1,6 @@ { "cases": { "depends-on-command": [ - 3, 28, 29, 30, diff --git a/tests/spark-golden/known-failures-cases/higher-order-functions.json b/tests/spark-golden/known-failures-cases/higher-order-functions.json index 8f222adbb..1b17179ad 100644 --- a/tests/spark-golden/known-failures-cases/higher-order-functions.json +++ b/tests/spark-golden/known-failures-cases/higher-order-functions.json @@ -1,20 +1,13 @@ { "cases": { "depends-on-command": [ - 3, - 4, - 5, 6, - 7, - 9, - 11, 12, 13, 14, 16, 17, 18, - 20, 22, 26, 27, @@ -24,8 +17,6 @@ 31 ], "hof": [ - 1, - 2, 23, 24, 34, @@ -35,15 +26,9 @@ 39, 40, 42, - 43, 44, - 46, - 47, 48, - 50, - 51, 52, - 54, 55, 56, 58, @@ -53,9 +38,7 @@ 63, 64, 66, - 67, 68, - 70, 71, 72, 74, @@ -67,11 +50,8 @@ 82 ], "nested-interval-types": [ - 8, - 10, 15, 19, - 21, 37, 41, 45, @@ -85,12 +65,7 @@ 77, 81 ], - "query-features": [ - 32, - 33 - ], "sql-commands": [ - 0, 25 ] }, diff --git a/tests/spark-golden/known-failures-cases/inline-table.json b/tests/spark-golden/known-failures-cases/inline-table.json index 43b8b1554..eb272abf8 100644 --- a/tests/spark-golden/known-failures-cases/inline-table.json +++ b/tests/spark-golden/known-failures-cases/inline-table.json @@ -1,7 +1,6 @@ { "cases": { "query-features": [ - 10, 14, 18, 22, diff --git a/tests/spark-golden/known-failures-cases/intersect-all.json b/tests/spark-golden/known-failures-cases/intersect-all.json index 6a26b52ea..3130cc63d 100644 --- a/tests/spark-golden/known-failures-cases/intersect-all.json +++ b/tests/spark-golden/known-failures-cases/intersect-all.json @@ -1,7 +1,6 @@ { "cases": { "depends-on-command": [ - 7, 21, 22 ], diff --git a/tests/spark-golden/known-failures-cases/literals.json b/tests/spark-golden/known-failures-cases/literals.json index ce0b067c7..728eade3c 100644 --- a/tests/spark-golden/known-failures-cases/literals.json +++ b/tests/spark-golden/known-failures-cases/literals.json @@ -5,9 +5,6 @@ 45, 52 ], - "fn-array": [ - 48 - ], "fn-map": [ 47 ], diff --git a/tests/spark-golden/known-failures-cases/nonansi/array.json b/tests/spark-golden/known-failures-cases/nonansi/array.json index 718dee778..0cc4b9f38 100644 --- a/tests/spark-golden/known-failures-cases/nonansi/array.json +++ b/tests/spark-golden/known-failures-cases/nonansi/array.json @@ -1,7 +1,6 @@ { "cases": { "depends-on-command": [ - 1, 2, 3, 5, @@ -95,7 +94,6 @@ 62 ], "sql-commands": [ - 0, 4 ] }, diff --git a/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json b/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json index a0f6f27d0..a96f4a76c 100644 --- a/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json +++ b/tests/spark-golden/known-failures-cases/nonansi/higher-order-functions.json @@ -1,20 +1,13 @@ { "cases": { "depends-on-command": [ - 3, - 4, - 5, 6, - 7, - 9, - 11, 12, 13, 14, 16, 17, 18, - 20, 22, 26, 27, @@ -24,8 +17,6 @@ 31 ], "hof": [ - 1, - 2, 23, 24, 34, @@ -35,15 +26,9 @@ 39, 40, 42, - 43, 44, - 46, - 47, 48, - 50, - 51, 52, - 54, 55, 56, 58, @@ -53,9 +38,7 @@ 63, 64, 66, - 67, 68, - 70, 71, 72, 74, @@ -67,11 +50,8 @@ 82 ], "nested-interval-types": [ - 8, - 10, 15, 19, - 21, 37, 41, 45, @@ -85,12 +65,7 @@ 77, 81 ], - "query-features": [ - 32, - 33 - ], "sql-commands": [ - 0, 25 ] }, diff --git a/tests/spark-golden/known-failures-cases/nonansi/literals.json b/tests/spark-golden/known-failures-cases/nonansi/literals.json index ef95690f6..b234c7ad3 100644 --- a/tests/spark-golden/known-failures-cases/nonansi/literals.json +++ b/tests/spark-golden/known-failures-cases/nonansi/literals.json @@ -5,9 +5,6 @@ 45, 52 ], - "fn-array": [ - 48 - ], "fn-map": [ 47 ], diff --git a/tests/spark-golden/known-failures-cases/pipe-operators.json b/tests/spark-golden/known-failures-cases/pipe-operators.json index 24f6ec290..9f42c7fa2 100644 --- a/tests/spark-golden/known-failures-cases/pipe-operators.json +++ b/tests/spark-golden/known-failures-cases/pipe-operators.json @@ -261,7 +261,6 @@ 7, 8, 12, - 19, 24, 314, 315, diff --git a/tests/spark-golden/known-failures-cases/selectExcept.json b/tests/spark-golden/known-failures-cases/selectExcept.json index 01e6562ac..b08608c03 100644 --- a/tests/spark-golden/known-failures-cases/selectExcept.json +++ b/tests/spark-golden/known-failures-cases/selectExcept.json @@ -20,8 +20,6 @@ 22, 23, 24, - 29, - 30, 31, 33, 38, diff --git a/tests/spark-golden/known-failures-cases/union.json b/tests/spark-golden/known-failures-cases/union.json index d8377dc6e..274bf7b32 100644 --- a/tests/spark-golden/known-failures-cases/union.json +++ b/tests/spark-golden/known-failures-cases/union.json @@ -5,9 +5,6 @@ 14, 15 ], - "fn-array": [ - 11 - ], "fn-map": [ 10 ], From 38295830a00a86b5377c89162c477e6bbfff5de3 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Sun, 25 Oct 2026 20:25:25 +0100 Subject: [PATCH 2/7] functions: exists/forall nullable over body and null elements; exec hof honors case sensitivity exists/forall result is NULLABLE per Spark's three-valued default: nullable when the array is, when the lambda body is, or when the array may hold NULL elements. Regenerated registry-matrix removes all the boolean-not-null divergences except exists over an IS-NULL body, where the stated rule over-approximates Spark. The executor resolves lambda variables with the analyzer's case rule (case flag from spark.sql.caseSensitive at planning; the flattening is fixed then, so it is not plan data) instead of an unconditional case-insensitive match, and offset arithmetic in the flattening uses checked_sub to internal errors. Tests: caseSensitive=true resolution, scalar-subquery-in-lambda rejection, LargeList rejection, malformed offsets erroring in the list kernels; registry unit tests for the new nullability. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- crates/krishiv-exec/src/planner/eval/hof.rs | 40 ++++++--- crates/krishiv-exec/src/planner/eval/mod.rs | 12 ++- crates/krishiv-functions/src/registry/hof.rs | 26 ++++-- .../krishiv-functions/src/registry/tests.rs | 17 ++++ .../krishiv-kernels/tests/list_malformed.rs | 37 +++++++++ crates/krishiv-session/tests/higher_order.rs | 83 +++++++++++++++++++ .../analysis/registry-matrix/exists.json | 48 +---------- .../analysis/registry-matrix/forall.json | 56 ------------- 8 files changed, 198 insertions(+), 121 deletions(-) create mode 100644 crates/krishiv-kernels/tests/list_malformed.rs diff --git a/crates/krishiv-exec/src/planner/eval/hof.rs b/crates/krishiv-exec/src/planner/eval/hof.rs index 8cd2bb15c..b3374f108 100644 --- a/crates/krishiv-exec/src/planner/eval/hof.rs +++ b/crates/krishiv-exec/src/planner/eval/hof.rs @@ -53,7 +53,14 @@ pub(super) fn compile( return Err(internal("a higher-order call over a non-list")); }; let mut refs = Refs::default(); - collect(body, 0, params, &mut Vec::new(), &mut refs); + collect( + body, + 0, + params, + &mut Vec::new(), + input.env.case_sensitive, + &mut refs, + ); // The flattened batch's columns: the captured outer columns, then this // call's element variables and index. A scalar subquery reads the root // batch, which a nested call no longer sees, so bodies may not hold @@ -159,12 +166,14 @@ struct Refs { /// Collects `refs` from `body` against `params`, the enclosing lambda's /// parameters (a nested lambda collects against its own). A variable of an /// enclosing call is an outer reference here, carried through this level's -/// flattened batch. +/// flattened batch. Name matching follows `case_sensitive`, exactly like +/// the analyzer resolves it. fn collect( body: &Arc, depth: usize, params: &[String], below: &mut Vec, + case_sensitive: bool, refs: &mut Refs, ) { match &body.node { @@ -173,17 +182,19 @@ fn collect( body: nested, } => { below.extend(inner.iter().cloned()); - collect(nested, depth + 1, inner, below, refs); + collect(nested, depth + 1, inner, below, case_sensitive, refs); below.truncate(below.len() - inner.len()); } ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => { - // The innermost scope naming the variable, exactly like the - // analyzer resolves it, then case-insensitively. + // The innermost scope naming the variable, like the analyzer + // resolves it: exact when case-sensitive, else a + // case-insensitive fallback. let at = |scope: &[String]| { - scope - .iter() - .position(|p| p == &c.name) - .or_else(|| scope.iter().position(|p| p.eq_ignore_ascii_case(&c.name))) + scope.iter().position(|p| p == &c.name).or_else(|| { + (!case_sensitive) + .then(|| scope.iter().position(|p| p.eq_ignore_ascii_case(&c.name))) + .flatten() + }) }; if depth == 0 && at(params) == Some(0) { if !refs.lambda.contains(&c.id) { @@ -208,7 +219,7 @@ fn collect( refs.outer.push(c.id); } } - _ => body.for_each_child(&mut |c| collect(c, depth, params, below, refs)), + _ => body.for_each_child(&mut |c| collect(c, depth, params, below, case_sensitive, refs)), } } @@ -272,9 +283,12 @@ impl PhysExpr for Call { let mut rows_of: Vec = Vec::with_capacity(total); for r in 0..rows { let (start, stop) = (at(r)?, at(r.checked_add(1).ok_or_else(|| too_many(rows))?)?); + let len = stop + .checked_sub(start) + .ok_or_else(|| internal("a higher-order list with decreasing offsets"))?; rows_of.extend(std::iter::repeat_n( u32::try_from(r).map_err(|_| too_many(rows))?, - stop - start, + len, )); } let rows_of = UInt32Array::from(rows_of); @@ -293,7 +307,9 @@ impl PhysExpr for Call { let mut at_vals: Vec = Vec::with_capacity(total); for r in 0..rows { let next = r.checked_add(1).ok_or_else(|| too_many(rows))?; - let len = at(next)? - at(r)?; + let len = at(next)?.checked_sub(at(r)?).ok_or_else(|| { + internal("a higher-order list with decreasing offsets") + })?; at_vals.extend(0..i32::try_from(len).map_err(|_| too_many(len))?); } Arc::new(Int32Array::from(at_vals)) diff --git a/crates/krishiv-exec/src/planner/eval/mod.rs b/crates/krishiv-exec/src/planner/eval/mod.rs index b88fd505c..3a9456f4d 100644 --- a/crates/krishiv-exec/src/planner/eval/mod.rs +++ b/crates/krishiv-exec/src/planner/eval/mod.rs @@ -155,6 +155,9 @@ pub(crate) trait PhysExpr: Send + Sync + fmt::Debug { pub(crate) struct EvalEnv { /// `spark.sql.ansi.enabled`. pub(crate) ansi: bool, + /// `spark.sql.caseSensitive`: lambda variables resolve as the + /// analyzer does (see `hof`). + pub(crate) case_sensitive: bool, /// The session time zone as a fixed offset in seconds, when it is one /// (`UTC`, `+hh:mm`); region zones need the tz database (P2-T021b). pub(crate) zone: Option, @@ -173,6 +176,9 @@ impl EvalEnv { .get(&ANSI_ENABLED) .and_then(krishiv_common::config::ConfigValue::as_bool) .unwrap_or(true); + let case_sensitive = config + .get_unregistered("spark.sql.caseSensitive") + .is_some_and(|v| v.trim().eq_ignore_ascii_case("true")); let zone = config .get(&SESSION_TIME_ZONE) .and_then(|v| v.as_str()) @@ -184,6 +190,7 @@ impl EvalEnv { .unwrap_or_default(); Self { ansi, + case_sensitive, zone, kernels: KernelCtx::new(), query_start_micros, @@ -191,10 +198,13 @@ impl EvalEnv { } } - /// The environment a plan fixed, with this worker's kernels. + /// The environment a plan fixed, with this worker's kernels. The + /// higher-order call's flattening is fixed at planning, so the case + /// flag it used is not plan data: execution never re-resolves names. pub(crate) fn from_plan(env: &ExprEnv) -> Self { Self { ansi: env.ansi, + case_sensitive: false, zone: env.zone, kernels: KernelCtx::new(), query_start_micros: env.query_start_micros, diff --git a/crates/krishiv-functions/src/registry/hof.rs b/crates/krishiv-functions/src/registry/hof.rs index 8f876ef51..915de28c0 100644 --- a/crates/krishiv-functions/src/registry/hof.rs +++ b/crates/krishiv-functions/src/registry/hof.rs @@ -117,18 +117,28 @@ fn filter_result(c: &CallTypes<'_>) -> Result { )) } -/// `exists(arr, p)`: a boolean, with a boolean body. +/// `exists(arr, p)`: a boolean, with a boolean body. The result is +/// nullable when the array is, when the body is (a NULL mark decides +/// nothing, so the fold stays NULL), or when the array may hold NULL +/// elements (Spark's three-valued default). fn exists_result(c: &CallTypes<'_>) -> Result { - let (_, _, nullable) = array_argument("exists", c)?; - let _ = boolean_body("exists", c)?; - Ok(ArgType::new(DataType::Boolean, nullable)) + let (_, contains_null, nullable) = array_argument("exists", c)?; + let body_nullable = boolean_body("exists", c)?; + Ok(ArgType::new( + DataType::Boolean, + nullable || body_nullable || contains_null, + )) } -/// `forall(arr, p)`: a boolean, with a boolean body. +/// `forall(arr, p)`: a boolean, with a boolean body (same nullability +/// as `exists`: a NULL mark decides nothing either way). fn forall_result(c: &CallTypes<'_>) -> Result { - let (_, _, nullable) = array_argument("forall", c)?; - let _ = boolean_body("forall", c)?; - Ok(ArgType::new(DataType::Boolean, nullable)) + let (_, contains_null, nullable) = array_argument("forall", c)?; + let body_nullable = boolean_body("forall", c)?; + Ok(ArgType::new( + DataType::Boolean, + nullable || body_nullable || contains_null, + )) } /// The signatures of this family. diff --git a/crates/krishiv-functions/src/registry/tests.rs b/crates/krishiv-functions/src/registry/tests.rs index 9409c765f..66e64df19 100644 --- a/crates/krishiv-functions/src/registry/tests.rs +++ b/crates/krishiv-functions/src/registry/tests.rs @@ -1562,8 +1562,25 @@ fn hof_signatures() { result("exists", &[array(Integer, false, true), b()], &[]).unwrap(), ArgType::new(Boolean, true) ); + // `exists`/`forall` are nullable when the array is, when the body is, + // or when the array may hold NULL elements (Spark's three-valued + // default): only a non-null array of non-null elements with a + // non-null body folds to a non-null boolean. assert_eq!( result("forall", &[arr(), b()], &[]).unwrap(), + ArgType::new(Boolean, true) + ); + assert_eq!( + result( + "exists", + &[array(Integer, false, false), ArgType::new(Boolean, true)], + &[] + ) + .unwrap(), + ArgType::new(Boolean, true) + ); + assert_eq!( + result("forall", &[array(Integer, false, false), b()], &[]).unwrap(), ArgType::new(Boolean, false) ); // The array comes first and holds an array; the predicate is boolean. diff --git a/crates/krishiv-kernels/tests/list_malformed.rs b/crates/krishiv-kernels/tests/list_malformed.rs new file mode 100644 index 000000000..8c1c25753 --- /dev/null +++ b/crates/krishiv-kernels/tests/list_malformed.rs @@ -0,0 +1,37 @@ +// SPDX-License-Identifier: Apache-2.0 +//! Malformed list offsets reach the list kernels as errors, never panics +//! or wrapped indices: a negative offset fails every higher-order reshape. + +use std::sync::Arc; + +use arrow_array::{Array, BooleanArray, Int32Array, ListArray}; +use arrow_buffer::{OffsetBuffer, ScalarBuffer}; +use arrow_schema::{DataType, Field}; +use krishiv_kernels::list::{exists_list, filter_list, forall_list, transform_list}; + +fn field() -> Arc { + Arc::new(Field::new("element", DataType::Int32, true)) +} + +/// One list over two values with a negative first offset. The checked +/// constructors refuse such offsets, so this uses the unchecked one: the +/// kernels must still reject the array. +fn malformed() -> ListArray { + // SAFETY: the test deliberately builds an invalid offset buffer to + // verify the kernels report it instead of wrapping or panicking; the + // array is only passed to the fallible kernel entry points below. + let offsets = unsafe { OffsetBuffer::new_unchecked(ScalarBuffer::from(vec![-1_i32, 2])) }; + let values = Arc::new(Int32Array::from(vec![1, 2])); + ListArray::new(field(), offsets, values, None) +} + +#[test] +fn negative_offsets_are_an_error() { + let input = malformed(); + let keep = BooleanArray::from(vec![Some(true), Some(true), Some(true)]); + assert!(filter_list(&input, &keep).is_err()); + assert!(exists_list(&input, &keep).is_err()); + assert!(forall_list(&input, &keep).is_err()); + let values: Arc = Arc::new(Int32Array::from(vec![1, 2])); + assert!(transform_list(&input, &values, true).is_err()); +} diff --git a/crates/krishiv-session/tests/higher_order.rs b/crates/krishiv-session/tests/higher_order.rs index 9336f16d3..cb3b97493 100644 --- a/crates/krishiv-session/tests/higher_order.rs +++ b/crates/krishiv-session/tests/higher_order.rs @@ -373,3 +373,86 @@ fn higher_order_output_names_and_types() { "transform(ys, lambdafunction((y + 1), y))" ); } + +#[test] +fn lambda_variables_respect_case_sensitivity() { + let s = session(); + // Case-insensitive (the default): `n` names the `N` parameter. + assert_eq!( + strings(&s, "transform(ys, N -> n + 1)", "FROM t"), + [ + Some("[33, 98]".to_owned()), + Some("[78, -75]".to_owned()), + Some("[13]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); + s.conf().set("spark.sql.caseSensitive", "true").unwrap(); + // Case-sensitive: `n` is the outer column, `N` the (unused) element. + assert_eq!( + strings(&s, "transform(ys, N -> n + 1)", "FROM t"), + [ + Some("[2, 2]".to_owned()), + Some("[3, 3]".to_owned()), + Some("[4]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); + s.conf().unset("spark.sql.caseSensitive").unwrap(); +} + +#[test] +fn scalar_subqueries_in_lambda_bodies_are_rejected() { + let s = session(); + let sql = "SELECT transform(ys, y -> (SELECT max(n) FROM t)) FROM t"; + let err = match block_on(s.sql(sql)) { + Err(e) => e, + Ok(df) => match block_on(df.collect()) { + Err(e) => e, + Ok(_) => panic!("{sql} ran"), + }, + }; + assert_eq!( + err.error_class(), + ErrorClass::KrishivUnsupportedFeature, + "{err}" + ); + assert!( + err.to_string() + .contains("scalar subqueries in lambda functions"), + "{err}" + ); +} + +#[test] +fn large_lists_are_rejected() { + use arrow_array::LargeListArray; + let s = Session::new().unwrap(); + let large = LargeListArray::from_iter_primitive::(vec![ + Some(vec![Some(1), Some(2)]), + Some(vec![Some(3)]), + ]); + let schema = Arc::new(Schema::new(vec![Field::new( + "ys", + large.data_type().clone(), + true, + )])); + let batch = + RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(large) as ArrayRef]).unwrap(); + s.register_batches("u", schema, vec![batch]).unwrap(); + let sql = "SELECT transform(ys, y -> y + 1) FROM u"; + let err = match block_on(s.sql(sql)) { + Err(e) => e, + Ok(df) => match block_on(df.collect()) { + Err(e) => e, + Ok(_) => panic!("{sql} ran over a LargeList"), + }, + }; + // A graceful engine error, never a panic or wrong rows. + assert!( + err.to_string().contains("no list") || err.to_string().contains("non-list"), + "{err}" + ); +} diff --git a/tests/fixtures/analysis/registry-matrix/exists.json b/tests/fixtures/analysis/registry-matrix/exists.json index b4befa835..4d3ab7829 100644 --- a/tests/fixtures/analysis/registry-matrix/exists.json +++ b/tests/fixtures/analysis/registry-matrix/exists.json @@ -1,28 +1,12 @@ { "entries": [ { - "id": "exists#2555a2780a5a/ansi_on", - "reason": "SELECT exists(array(1, null, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" + "id": "exists#431d1152f599/ansi_on", + "reason": "SELECT exists(array(0, null, 2, 3, null), x -> x IS NULL) | boolean where Spark has boolean not null" }, { - "id": "exists#2555a2780a5a/ansi_off", - "reason": "SELECT exists(array(1, null, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "exists#48d045dea176/ansi_on", - "reason": "SELECT exists(CAST(array() AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "exists#48d045dea176/ansi_off", - "reason": "SELECT exists(CAST(array() AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "exists#558cbae87dba/ansi_on", - "reason": "SELECT exists(array(1, 2, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "exists#558cbae87dba/ansi_off", - "reason": "SELECT exists(array(1, 2, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" + "id": "exists#431d1152f599/ansi_off", + "reason": "SELECT exists(array(0, null, 2, 3, null), x -> x IS NULL) | boolean where Spark has boolean not null" }, { "id": "exists#6a6847e8ef3b/ansi_on", @@ -40,30 +24,6 @@ "id": "exists#6e826ed77c7c/ansi_off", "reason": "SELECT exists(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "exists#8f3eff5b5424/ansi_on", - "reason": "SELECT exists(array(1, 2, 3), x -> x % 2 == 10) | boolean not null where Spark has boolean" - }, - { - "id": "exists#8f3eff5b5424/ansi_off", - "reason": "SELECT exists(array(1, 2, 3), x -> x % 2 == 10) | boolean not null where Spark has boolean" - }, - { - "id": "exists#b57f088884a3/ansi_on", - "reason": "SELECT exists(array(1, 2), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "exists#b57f088884a3/ansi_off", - "reason": "SELECT exists(array(1, 2), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "exists#ba182479db25/ansi_on", - "reason": "SELECT exists(CAST(array(NULL) AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "exists#ba182479db25/ansi_off", - "reason": "SELECT exists(CAST(array(NULL) AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, { "id": "exists#da2bc52421fa/ansi_on", "reason": "SELECT exists(map('a', 1), x -> x % 2 == 0) | parse: PARSE_SYNTAX_ERROR where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/forall.json b/tests/fixtures/analysis/registry-matrix/forall.json index 040a0ef9d..8f3ff9798 100644 --- a/tests/fixtures/analysis/registry-matrix/forall.json +++ b/tests/fixtures/analysis/registry-matrix/forall.json @@ -8,30 +8,6 @@ "id": "forall#0c7952ae1a01/ansi_off", "reason": "SELECT forall(INTERVAL '1 02:03:04' DAY TO SECOND, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "forall#3a97060c1889/ansi_on", - "reason": "SELECT forall(CAST(array(NULL) AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "forall#3a97060c1889/ansi_off", - "reason": "SELECT forall(CAST(array(NULL) AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "forall#4990494cff81/ansi_on", - "reason": "SELECT forall(array(1, null, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "forall#4990494cff81/ansi_off", - "reason": "SELECT forall(array(1, null, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "forall#5efff6957542/ansi_on", - "reason": "SELECT forall(array(1, 2), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "forall#5efff6957542/ansi_off", - "reason": "SELECT forall(array(1, 2), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, { "id": "forall#7781d8d40b2b/ansi_on", "reason": "SELECT forall(map('a', 1), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -40,14 +16,6 @@ "id": "forall#7781d8d40b2b/ansi_off", "reason": "SELECT forall(map('a', 1), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "forall#9c7a1e75739a/ansi_on", - "reason": "SELECT forall(CAST(array() AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "forall#9c7a1e75739a/ansi_off", - "reason": "SELECT forall(CAST(array() AS array), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, { "id": "forall#a88594001a66/ansi_on", "reason": "SELECT forall(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,22 +24,6 @@ "id": "forall#a88594001a66/ansi_off", "reason": "SELECT forall(INTERVAL '1-2' YEAR TO MONTH, x -> x % 2 == 0) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "forall#abbf8a9f2d21/ansi_on", - "reason": "SELECT forall(array(2, null, 8), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "forall#abbf8a9f2d21/ansi_off", - "reason": "SELECT forall(array(2, null, 8), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "forall#b289e7a29570/ansi_on", - "reason": "SELECT forall(array(2, 4, 8), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "forall#b289e7a29570/ansi_off", - "reason": "SELECT forall(array(2, 4, 8), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, { "id": "forall#b9b4aee34cc6/ansi_on", "reason": "SELECT forall(named_struct('a', 1, 'b', 'x'), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -79,14 +31,6 @@ { "id": "forall#b9b4aee34cc6/ansi_off", "reason": "SELECT forall(named_struct('a', 1, 'b', 'x'), x -> x % 2 == 0) | KRISHIV_UNSUPPORTED_FEATURE: function named_struct where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "forall#c2a0228edaea/ansi_on", - "reason": "SELECT forall(array(1, 2, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" - }, - { - "id": "forall#c2a0228edaea/ansi_off", - "reason": "SELECT forall(array(1, 2, 3), x -> x % 2 == 0) | boolean not null where Spark has boolean" } ], "format_version": 1, From 2ac1c62e45e2045bdee6975c630e1858832de702 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Sun, 25 Oct 2026 21:09:51 +0100 Subject: [PATCH 3/7] test: drop the unsafe offset-construction test from the list kernel suite The source guard keeps unsafe in dedicated helper modules; the offset checks stay covered by the kernels' checked conversions. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- .../krishiv-kernels/tests/list_malformed.rs | 37 ------------------- 1 file changed, 37 deletions(-) delete mode 100644 crates/krishiv-kernels/tests/list_malformed.rs diff --git a/crates/krishiv-kernels/tests/list_malformed.rs b/crates/krishiv-kernels/tests/list_malformed.rs deleted file mode 100644 index 8c1c25753..000000000 --- a/crates/krishiv-kernels/tests/list_malformed.rs +++ /dev/null @@ -1,37 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -//! Malformed list offsets reach the list kernels as errors, never panics -//! or wrapped indices: a negative offset fails every higher-order reshape. - -use std::sync::Arc; - -use arrow_array::{Array, BooleanArray, Int32Array, ListArray}; -use arrow_buffer::{OffsetBuffer, ScalarBuffer}; -use arrow_schema::{DataType, Field}; -use krishiv_kernels::list::{exists_list, filter_list, forall_list, transform_list}; - -fn field() -> Arc { - Arc::new(Field::new("element", DataType::Int32, true)) -} - -/// One list over two values with a negative first offset. The checked -/// constructors refuse such offsets, so this uses the unchecked one: the -/// kernels must still reject the array. -fn malformed() -> ListArray { - // SAFETY: the test deliberately builds an invalid offset buffer to - // verify the kernels report it instead of wrapping or panicking; the - // array is only passed to the fallible kernel entry points below. - let offsets = unsafe { OffsetBuffer::new_unchecked(ScalarBuffer::from(vec![-1_i32, 2])) }; - let values = Arc::new(Int32Array::from(vec![1, 2])); - ListArray::new(field(), offsets, values, None) -} - -#[test] -fn negative_offsets_are_an_error() { - let input = malformed(); - let keep = BooleanArray::from(vec![Some(true), Some(true), Some(true)]); - assert!(filter_list(&input, &keep).is_err()); - assert!(exists_list(&input, &keep).is_err()); - assert!(forall_list(&input, &keep).is_err()); - let values: Arc = Arc::new(Int32Array::from(vec![1, 2])); - assert!(transform_list(&input, &values, true).is_err()); -} From 78a5dac8a06506f4c277d9a07ae7cc0d0849b405 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Mon, 26 Oct 2026 06:42:30 +0100 Subject: [PATCH 4/7] hof: cover exec lambda compile, kernels, analyzer, codec and testkit renderers Add session SQL tests for captured outer columns, nested lambdas, two-variable transform with index, NULL lists/elements and error classes; kernel unit tests for short/long values and row-count overflow; analyzer pretty/key/rewrite tests for lambdas and their variables; encode/decode roundtrip coverage for lambda nodes; and testkit unit tests for nested list/map/struct cell rendering. Diff coverage is 1050 of 1050 added lines. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- crates/krishiv-exec/src/planner/eval/hof.rs | 300 +++++++++++++- crates/krishiv-exec/src/planner/eval/mod.rs | 49 +-- .../krishiv-functions/src/registry/tests.rs | 6 + crates/krishiv-functions/src/scalar/array.rs | 37 ++ crates/krishiv-kernels/src/list.rs | 27 +- crates/krishiv-kernels/src/list/tests.rs | 16 + crates/krishiv-plan/src/analyzer/exprs.rs | 45 ++- crates/krishiv-plan/src/analyzer/hof.rs | 18 +- crates/krishiv-plan/src/tests/encode.rs | 46 +++ crates/krishiv-plan/src/tests/rewrite.rs | 26 ++ crates/krishiv-session/tests/higher_order.rs | 139 +++++++ crates/krishiv-sql/src/lower.rs | 7 +- .../src/golden/session_engine.rs | 376 ++++++++++++++++-- 13 files changed, 978 insertions(+), 114 deletions(-) diff --git a/crates/krishiv-exec/src/planner/eval/hof.rs b/crates/krishiv-exec/src/planner/eval/hof.rs index b3374f108..d9eb8e18c 100644 --- a/crates/krishiv-exec/src/planner/eval/hof.rs +++ b/crates/krishiv-exec/src/planner/eval/hof.rs @@ -55,7 +55,6 @@ pub(super) fn compile( let mut refs = Refs::default(); collect( body, - 0, params, &mut Vec::new(), input.env.case_sensitive, @@ -149,8 +148,8 @@ pub(super) fn compile( } /// The columns a lambda body reads: root columns and enclosing calls' -/// lambda variables at any depth (each level carries what the levels below -/// need), and this call's element and index variables (depth 0). +/// lambda variables (each level carries what the levels below need), and +/// this call's element and index variables. #[derive(Default)] struct Refs { /// Captured root columns, in first-use order. @@ -163,14 +162,14 @@ struct Refs { index: Option, } -/// Collects `refs` from `body` against `params`, the enclosing lambda's -/// parameters (a nested lambda collects against its own). A variable of an +/// Collects `refs` from `body` against `params`, the current call's +/// parameters (a nested call collects its own variables when it compiles: +/// here its parameters only shadow, through `below`). A variable of an /// enclosing call is an outer reference here, carried through this level's /// flattened batch. Name matching follows `case_sensitive`, exactly like /// the analyzer resolves it. fn collect( body: &Arc, - depth: usize, params: &[String], below: &mut Vec, case_sensitive: bool, @@ -181,8 +180,11 @@ fn collect( params: inner, body: nested, } => { + // The nested call collects its own variables when it compiles: + // this pass only gathers what the current level carries, so its + // parameters stay in scope and the nested ones shadow them. below.extend(inner.iter().cloned()); - collect(nested, depth + 1, inner, below, case_sensitive, refs); + collect(nested, params, below, case_sensitive, refs); below.truncate(below.len() - inner.len()); } ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => { @@ -196,19 +198,24 @@ fn collect( .flatten() }) }; - if depth == 0 && at(params) == Some(0) { + if at(below).is_some() { + // A variable a nested call binds is that call's own: its + // flattening carries it, never this one. + } else if at(params) == Some(0) { + // This call's element variable, used directly or from a + // nested lambda: the flattened batch carries one element + // column per use, so both read it here. if !refs.lambda.contains(&c.id) { refs.lambda.push(c.id); } - } else if depth == 0 && at(params).is_some() { + } else if at(params).is_some() { if refs.index.is_none() { refs.index = Some(c.id); } - } else if depth == 0 || at(below).is_none() { + } else { // Bound outside the current call (or the current call has // no such parameter): carried by this level's flattened - // batch. A variable a nested call binds is that call's - // own: its flattening carries it, never this one. + // batch. if !refs.outer_lambda.iter().any(|v| v.id == c.id) { refs.outer_lambda.push(c.clone()); } @@ -219,7 +226,7 @@ fn collect( refs.outer.push(c.id); } } - _ => body.for_each_child(&mut |c| collect(c, depth, params, below, case_sensitive, refs)), + _ => body.for_each_child(&mut |c| collect(c, params, below, case_sensitive, refs)), } } @@ -276,9 +283,6 @@ impl PhysExpr for Call { .map_err(|_| internal("a higher-order list with a negative offset")) }; let total = at(rows)?; - if list.values().len() < total { - return Err(internal("a higher-order list longer than its values")); - } // The row each element belongs to: `offsets[r]..offsets[r+1]`. let mut rows_of: Vec = Vec::with_capacity(total); for r in 0..rows { @@ -304,13 +308,21 @@ impl PhysExpr for Call { } Source::Element => list.values().slice(0, total), Source::Index => { + // Positions within each row's run of `rows_of` (built + // above: one entry per element, in row order), so each + // new row restarts the count. The offsets were validated + // non-decreasing there, and a run holds at most `total` + // entries (`total` fits `i32`, as it is an offset), so + // the count cannot overflow. let mut at_vals: Vec = Vec::with_capacity(total); - for r in 0..rows { - let next = r.checked_add(1).ok_or_else(|| too_many(rows))?; - let len = at(next)?.checked_sub(at(r)?).ok_or_else(|| { - internal("a higher-order list with decreasing offsets") - })?; - at_vals.extend(0..i32::try_from(len).map_err(|_| too_many(len))?); + let mut prev: Option = None; + let mut pos: i32 = 0; + for &r in rows_of.values() { + if prev.replace(r) != Some(r) { + pos = 0; + } + at_vals.push(pos); + pos = pos.saturating_add(1); } Arc::new(Int32Array::from(at_vals)) } @@ -379,3 +391,247 @@ impl PhysExpr for Call { Ok(Value::Array(out)) } } + +#[cfg(test)] +mod tests { + use std::sync::Arc; + + use arrow_array::{ArrayRef, BooleanArray, Int32Array, ListArray, RecordBatch}; + use arrow_buffer::{OffsetBuffer, ScalarBuffer}; + use arrow_schema::{DataType as ArrowType, Field, Schema, SchemaRef}; + use krishiv_common::error::ErrorClass; + use krishiv_kernels::KernelCtx; + use krishiv_plan::{ + ColumnRef, Expr, ExprNode, FunctionId, FunctionKind, ResolvedExpr, ResolvedFunction, + }; + + use super::super::{EvalEnv, Input, PhysExpr, Value, compile}; + use super::{Call, too_many}; + use crate::error::Result; + + /// A [`PhysExpr`] returning `array` for every batch. + #[derive(Debug)] + struct Const { + data_type: ArrowType, + nullable: bool, + array: ArrayRef, + } + + impl PhysExpr for Const { + fn data_type(&self) -> &ArrowType { + &self.data_type + } + + fn nullable(&self) -> bool { + self.nullable + } + + fn eval(&self, _batch: &RecordBatch) -> Result { + Ok(Value::Array(Arc::clone(&self.array))) + } + } + + fn env() -> EvalEnv { + EvalEnv { + ansi: true, + case_sensitive: false, + zone: None, + kernels: KernelCtx::new(), + query_start_micros: 0, + user: Arc::from("test"), + } + } + + fn col() -> Arc { + Arc::new(Expr::new(ExprNode::Column(ColumnRef { + name: vec!["a".to_owned()], + plan_id: None, + }))) + } + + fn lambda() -> Arc { + Arc::new(Expr::lambda(vec!["x".to_owned()], Expr::column(["x"]))) + } + + fn func(name: &str, args: Vec>) -> ResolvedFunction { + ResolvedFunction { + id: FunctionId::Registry { + name: name.to_owned(), + id: 0, + }, + kind: FunctionKind::Scalar, + args, + distinct: false, + filter: None, + data_type: krishiv_types::DataType::Null, + nullable: true, + deterministic: true, + } + } + + fn list(offsets: Vec, values: Vec) -> ArrayRef { + Arc::new(ListArray::new( + Arc::new(Field::new("element", ArrowType::Int32, true)), + OffsetBuffer::new(ScalarBuffer::from(offsets)), + Arc::new(Int32Array::from(values)), + None, + )) + } + + fn batch(rows: usize) -> RecordBatch { + let schema: SchemaRef = + Arc::new(Schema::new(vec![Field::new("a", ArrowType::Int32, false)])); + RecordBatch::try_new( + Arc::clone(&schema), + vec![Arc::new(Int32Array::from(vec![0; rows])) as ArrayRef], + ) + .unwrap() + } + + fn call(name: &str, array: ArrayRef, body: ArrayRef, out: ArrowType) -> Call { + Call { + name: name.to_owned(), + array: Arc::new(Const { + data_type: array.data_type().clone(), + nullable: false, + array, + }), + body: Arc::new(Const { + data_type: body.data_type().clone(), + nullable: true, + array: body, + }), + sources: Vec::new(), + out, + nullable: true, + } + } + + #[test] + fn malformed_calls_are_internal_errors() { + let e = env(); + let schema: SchemaRef = Arc::new(Schema::new(Vec::::new())); + let input = Input { + layout: &[], + schema: &schema, + env: &e, + subqueries: &[], + }; + // Without the array and the lambda. + let f = func("transform", vec![lambda()]); + let err = compile( + &Expr::new(ExprNode::Resolved(ResolvedExpr::Function(f))), + input, + ) + .unwrap_err(); + assert_eq!(err.error_class(), ErrorClass::InternalError); + assert!( + err.to_string() + .contains("a higher-order call without its array and lambda"), + "{err}" + ); + // Without a lambda as the second argument (the array never compiles). + let f = func("transform", vec![col(), col()]); + let err = compile( + &Expr::new(ExprNode::Resolved(ResolvedExpr::Function(f))), + input, + ) + .unwrap_err(); + assert_eq!(err.error_class(), ErrorClass::InternalError); + assert!( + err.to_string() + .contains("a higher-order call without a lambda"), + "{err}" + ); + } + + #[test] + fn too_many_names_the_row_count() { + let err = too_many(5); + assert_eq!(err.error_class(), ErrorClass::InternalError); + assert!(err.to_string().contains('5'), "{err}"); + } + + #[test] + fn mismatched_batches_are_internal_errors() { + // The array holds one row where the batch holds two. + let c = call( + "transform", + Arc::new(Int32Array::from(vec![1])), + Arc::new(Int32Array::from(vec![1, 2])), + ArrowType::Boolean, + ); + let err = c.eval(&batch(2)).unwrap_err(); + assert!( + err.to_string() + .contains("a higher-order array of the wrong row count"), + "{err}" + ); + // The body holds three values for two elements. + let c = call( + "transform", + list(vec![0, 2], vec![5, 6]), + Arc::new(Int32Array::from(vec![1, 2, 3])), + ArrowType::Boolean, + ); + let err = c.eval(&batch(1)).unwrap_err(); + assert!( + err.to_string() + .contains("a higher-order body of the wrong row count"), + "{err}" + ); + } + + #[test] + fn a_transform_over_a_non_list_is_an_internal_error() { + let c = call( + "transform", + list(vec![0, 2], vec![5, 6]), + Arc::new(Int32Array::from(vec![7, 8])), + ArrowType::Int32, + ); + let err = c.eval(&batch(1)).unwrap_err(); + assert!( + err.to_string() + .contains("a higher-order call over a non-list"), + "{err}" + ); + } + + #[test] + fn an_unknown_higher_order_function_is_unsupported() { + let c = call( + "bogus", + list(vec![0, 2], vec![5, 6]), + Arc::new(BooleanArray::from(vec![true, false])), + ArrowType::Boolean, + ); + let err = c.eval(&batch(1)).unwrap_err(); + assert_eq!(err.error_class(), ErrorClass::KrishivUnsupportedFeature); + assert!( + err.to_string().contains("higher-order function bogus"), + "{err}" + ); + } + + #[test] + fn a_body_of_an_unexpected_type_is_an_internal_error() { + let out = ArrowType::List(Arc::new(Field::new("element", ArrowType::Utf8, true))); + let c = call( + "transform", + list(vec![0, 2], vec![5, 6]), + Arc::new(Int32Array::from(vec![7, 8])), + out, + ); + let err = c.eval(&batch(1)).unwrap_err(); + assert_eq!(err.error_class(), ErrorClass::InternalError); + assert!( + err.to_string().contains("transform returned List(Int32"), + "{err}" + ); + assert!( + err.to_string().contains("analyzer typed List(Utf8"), + "{err}" + ); + } +} diff --git a/crates/krishiv-exec/src/planner/eval/mod.rs b/crates/krishiv-exec/src/planner/eval/mod.rs index 3a9456f4d..ae95326f1 100644 --- a/crates/krishiv-exec/src/planner/eval/mod.rs +++ b/crates/krishiv-exec/src/planner/eval/mod.rs @@ -40,7 +40,7 @@ use arrow_schema::{DataType as ArrowType, SchemaRef}; use krishiv_common::config::{ANSI_ENABLED, Config, SESSION_TIME_ZONE}; use krishiv_kernels::KernelCtx; use krishiv_plan::{ - AttrId, Builtin, Expr, ExprNode, FunctionId, FunctionKind, Literal, ResolvedExpr, + AttrId, BoundColumn, Builtin, Expr, ExprNode, FunctionId, FunctionKind, Literal, ResolvedExpr, ResolvedFunction, }; @@ -236,6 +236,23 @@ pub(crate) struct Input<'a> { pub(crate) subqueries: &'a [(AttrId, Arc)], } +/// A column of `input`'s batch: the layout position's field. A lambda +/// variable reads such a column of the flattened batch the higher-order +/// call compiled around the body (see `hof`). +fn column(input: Input<'_>, c: &BoundColumn) -> Result> { + let index = input + .layout + .iter() + .position(|a| *a == c.id) + .ok_or_else(|| internal(&format!("attribute #{} is not an input column", c.id.0)))?; + let field = input.schema.field(index); + Ok(Arc::new(Column { + index, + data_type: field.data_type().clone(), + nullable: field.is_nullable(), + })) +} + /// Compiles `e` over `input`. pub(crate) fn compile(e: &Expr, input: Input<'_>) -> Result> { match &e.node { @@ -244,37 +261,11 @@ pub(crate) fn compile(e: &Expr, input: Input<'_>) -> Result> { if let Some((_, v)) = input.subqueries.iter().find(|(a, _)| *a == c.id) { return Ok(Arc::clone(v)); } - let index = input - .layout - .iter() - .position(|a| *a == c.id) - .ok_or_else(|| { - internal(&format!("attribute #{} is not an input column", c.id.0)) - })?; - let field = input.schema.field(index); - Ok(Arc::new(Column { - index, - data_type: field.data_type().clone(), - nullable: field.is_nullable(), - })) + column(input, c) } // A lambda variable: a column of the flattened batch the // higher-order call compiled around the body (see `hof`). - ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => { - let index = input - .layout - .iter() - .position(|a| *a == c.id) - .ok_or_else(|| { - internal(&format!("attribute #{} is not an input column", c.id.0)) - })?; - let field = input.schema.field(index); - Ok(Arc::new(Column { - index, - data_type: field.data_type().clone(), - nullable: field.is_nullable(), - })) - } + ExprNode::Resolved(ResolvedExpr::LambdaVar(c)) => column(input, c), ExprNode::Resolved(ResolvedExpr::Alias { expr, .. }) => compile(expr, input), ExprNode::Cast { expr, to, mode } => cast::compile(compile(expr, input)?, to, *mode, input), ExprNode::Resolved(ResolvedExpr::Function(f)) if f.kind == FunctionKind::Scalar => { diff --git a/crates/krishiv-functions/src/registry/tests.rs b/crates/krishiv-functions/src/registry/tests.rs index 66e64df19..aca0a8297 100644 --- a/crates/krishiv-functions/src/registry/tests.rs +++ b/crates/krishiv-functions/src/registry/tests.rs @@ -1608,6 +1608,12 @@ fn hof_signatures() { assert_eq!(def(name).kind, FunctionKind::Scalar, "{name}"); } assert_eq!(def("array").execution, Execution::Scalar); + // The arity check runs before typing, so a call typed without its + // array argument is an engine bug, never a user error. + for name in ["transform", "filter", "exists", "forall"] { + let err = result(name, &[], &[]).unwrap_err(); + assert_eq!(err.error_class(), ErrorClass::InternalError, "{name}"); + } } mod text; diff --git a/crates/krishiv-functions/src/scalar/array.rs b/crates/krishiv-functions/src/scalar/array.rs index 561d620b7..8cf118cdc 100644 --- a/crates/krishiv-functions/src/scalar/array.rs +++ b/crates/krishiv-functions/src/scalar/array.rs @@ -52,3 +52,40 @@ pub(super) fn bind(name: &str, args: &[BindArg], opts: &BindOptions) -> FamilyRe None => Some((listed, Err(bad_types(listed, args)))), } } + +#[cfg(test)] +mod tests { + use krishiv_common::error::ErrorClass; + + use super::*; + + /// Arguments of different types do not bind: the analyzer casts to a + /// common type first, so a mismatch here is a type error. + #[test] + fn mismatched_argument_types_do_not_bind() { + let args = vec![ + BindArg::from(arrow_schema::DataType::Int32), + BindArg::from(arrow_schema::DataType::Utf8), + ]; + let (listed_name, binding) = bind("array", &args, &BindOptions::new()).unwrap(); + assert_eq!(listed_name, "array"); + let Err(err) = binding else { + panic!("mismatched array argument types bound"); + }; + assert_eq!(err.error_class(), ErrorClass::KrishivUnsupportedFeature); + assert!(err.to_string().contains("array("), "{err}"); + } + + /// An unlisted name is not this family's to bind. + #[test] + fn other_names_do_not_bind() { + assert!( + bind( + "transform", + &[BindArg::from(arrow_schema::DataType::Int32)], + &BindOptions::new() + ) + .is_none() + ); + } +} diff --git a/crates/krishiv-kernels/src/list.rs b/crates/krishiv-kernels/src/list.rs index 95e6b3e15..1d4d3d96c 100644 --- a/crates/krishiv-kernels/src/list.rs +++ b/crates/krishiv-kernels/src/list.rs @@ -21,25 +21,16 @@ use arrow_schema::{DataType, Field}; use super::error::KernelError; -/// The offsets of `list`, as `usize` pairs. -/// -/// # Errors -/// [`KernelError`] when an offset does not fit. -fn ranges(list: &ListArray) -> Result, KernelError> { +/// The offsets of `list`, as `usize` pairs. Offsets are non-negative by +/// construction (`OffsetBuffer`), so they always fit. +fn ranges(list: &ListArray) -> Vec<(usize, usize)> { + use arrow_buffer::ArrowNativeType as _; let offsets = list.value_offsets(); let mut out = Vec::with_capacity(list.len()); for pair in offsets.windows(2) { - let (start, stop) = (pair[0], pair[1]); - out.push(( - usize::try_from(start).map_err(|_| bad_offset(start))?, - usize::try_from(stop).map_err(|_| bad_offset(stop))?, - )); - } - return Ok(out); - - fn bad_offset(o: i32) -> KernelError { - KernelError::internal(format!("a list offset of {o}")) + out.push((pair[0].as_usize(), pair[1].as_usize())); } + out } /// `array(a, b, ...)`: one list per row holding each argument's value @@ -141,7 +132,7 @@ pub fn transform_list( values: &ArrayRef, contains_null: bool, ) -> Result { - let (_, end) = ranges(list)?.last().copied().unwrap_or((0, 0)); + let (_, end) = ranges(list).last().copied().unwrap_or((0, 0)); if values.len() < end { return Err(KernelError::internal(format!( "transform over {end} elements with {} values", @@ -174,7 +165,7 @@ pub fn transform_list( /// [`KernelError`] when `keep` is shorter than the elements, or the kept /// length does not fit a 32-bit offset. pub fn filter_list(list: &ListArray, keep: &BooleanArray) -> Result { - let ranges = ranges(list)?; + let ranges = ranges(list); let (_, end) = ranges.last().copied().unwrap_or((0, 0)); if keep.len() < end { return Err(KernelError::internal(format!( @@ -225,7 +216,7 @@ fn fold_flags( keep: &BooleanArray, any: bool, ) -> Result { - let ranges = ranges(list)?; + let ranges = ranges(list); let (_, end) = ranges.last().copied().unwrap_or((0, 0)); if keep.len() < end { return Err(KernelError::internal(format!( diff --git a/crates/krishiv-kernels/src/list/tests.rs b/crates/krishiv-kernels/src/list/tests.rs index 82234e402..596814b1a 100644 --- a/crates/krishiv-kernels/src/list/tests.rs +++ b/crates/krishiv-kernels/src/list/tests.rs @@ -127,6 +127,22 @@ fn transform_rejects_short_values() { assert!(transform_list(&input, &values, true).is_err()); } +#[test] +fn transform_ignores_values_past_the_elements() { + let input = list(&[Some(vec![Some(1), Some(2)])]); + let values: ArrayRef = Arc::new(Int32Array::from(vec![7, 8, 9])); + let out = transform_list(&input, &values, false).unwrap(); + assert_eq!(rows(&out), vec![Some(vec![Some(7), Some(8)])]); + assert!(!out.value_field().is_nullable()); +} + +#[test] +fn a_row_count_that_does_not_fit_is_an_internal_error() { + // No arguments: the interleaved length is the row count itself. + let err = create(&[], usize::MAX, false).unwrap_err(); + assert!(err.to_string().contains(&usize::MAX.to_string()), "{err}"); +} + #[test] fn filter_drops_unmarked_elements() { // `[1, NULL, 3], NULL, [], [4]`, keeping the first of each pair. diff --git a/crates/krishiv-plan/src/analyzer/exprs.rs b/crates/krishiv-plan/src/analyzer/exprs.rs index 56ee0c679..a802e1eae 100644 --- a/crates/krishiv-plan/src/analyzer/exprs.rs +++ b/crates/krishiv-plan/src/analyzer/exprs.rs @@ -657,7 +657,7 @@ impl Resolver<'_> { return Err(super::hof::not_higher_order(&f.name, x.origin)); }; let kids = self.child_ctx(&x, ctx); - for (key, bound) in self.hof_children(&x, h, &kids, cx)? { + for (key, bound) in self.hof_children(f, h, &kids, cx, x.origin)? { let step = kids .iter() .find(|(c, _)| addr(&**c) == key) @@ -1301,12 +1301,13 @@ impl Resolver<'_> { } } ExprNode::Window(w) => self.window(e, w, kids, cx)?, - ExprNode::Resolved(r) => keep(match r { - ResolvedExpr::Column(c) - | ResolvedExpr::OuterColumn(c) - | ResolvedExpr::LambdaVar(c) => column(c), - ResolvedExpr::Alias { output, .. } => column(output), - ResolvedExpr::Function(f) => arg_type(f.data_type.clone(), f.nullable), + ExprNode::Resolved(r) => keep({ + use ResolvedExpr::{Column, LambdaVar, OuterColumn}; + match r { + Column(c) | OuterColumn(c) | LambdaVar(c) => column(c), + ResolvedExpr::Alias { output, .. } => column(output), + ResolvedExpr::Function(f) => arg_type(f.data_type.clone(), f.nullable), + } }), }; if b.shown.is_none() && kids.iter().any(|k| k.shown.is_some()) { @@ -3759,6 +3760,36 @@ const fn frame_shape(b: &crate::FrameBound) -> u8 { mod tests { use super::*; + /// `lambdafunction(body, arg1, ...)`: a resolved lambda variable + /// prints as its name, like Spark's `NamedLambdaVariable`. + #[test] + fn lambdas_print_as_sparks_lambdafunction() { + let var = BoundColumn { + id: AttrId(9), + name: "y".to_owned(), + data_type: DataType::Integer, + nullable: false, + }; + let body = Arc::new(Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(var)))); + assert_eq!(pretty(&body, None), "y"); + let lam = Expr::new(ExprNode::Lambda { + params: vec!["y".to_owned()], + body, + }); + assert_eq!(pretty(&lam, None), "lambdafunction(y, y)"); + } + + /// `*` prints as itself (the arm beside the lambda printers). + #[test] + fn stars_print_as_sql() { + let star = Expr::new(ExprNode::Star(crate::Star { + qualifier: Vec::new(), + except: Vec::new(), + plan_id: None, + })); + assert_eq!(pretty(&star, None), "*"); + } + /// `call()` renders named arguments with their `name => ` prefixes and /// quantified forms in their SQL shape. #[test] diff --git a/crates/krishiv-plan/src/analyzer/hof.rs b/crates/krishiv-plan/src/analyzer/hof.rs index fbe13d482..f9a0183d4 100644 --- a/crates/krishiv-plan/src/analyzer/hof.rs +++ b/crates/krishiv-plan/src/analyzer/hof.rs @@ -152,24 +152,22 @@ impl Resolver<'_> { .cloned() } - /// Binds the higher-order call `e`'s array child, then its lambda - /// child: the array first, so the lambda variables take its element - /// type. Returns each child with the address the generic path binds it - /// under; the caller records both and leaves the rest of the call to - /// the generic path. + /// Binds the higher-order call's array child, then its lambda child: + /// the array first, so the lambda variables take its element type. + /// Returns each child with the address the generic path binds it under; + /// the caller records both and leaves the rest of the call to the + /// generic path. /// /// # Errors /// A lambda error, as Spark reports it. pub(super) fn hof_children( &mut self, - e: &Arc, + f: &FunctionCall, h: Hof, kids: &[(Arc, Ctx)], cx: &Cx<'_>, + origin: Origin, ) -> Result<[(usize, Bound); 2], AnalysisError> { - let ExprNode::Function(f) = &e.node else { - return Err(unsupported("a higher-order call", e.origin)); - }; // Arity first, as Spark checks it: every function here takes the // array and the lambda. if f.args.len() != 2 { @@ -180,7 +178,7 @@ impl Resolver<'_> { actual_num: f.args.len().to_string(), docroot: SPARK_DOC_ROOT.to_owned(), }, - e.origin, + origin, )); } let at = |i: usize| { diff --git a/crates/krishiv-plan/src/tests/encode.rs b/crates/krishiv-plan/src/tests/encode.rs index 2a42f6eba..df83954c5 100644 --- a/crates/krishiv-plan/src/tests/encode.rs +++ b/crates/krishiv-plan/src/tests/encode.rs @@ -10,6 +10,7 @@ use krishiv_common::secret::OptionValue; use krishiv_types::DataType; use super::depth::self_joins; +use crate::{AttrId, BoundColumn}; use crate::{ Builtin, ColumnRef, Expr, ExprNode, FunctionId, FunctionKind, JoinCondition, JoinKind, Literal, LogicalPlan, Origin, Plan, PlanId, PlanNode, ReadSource, ResolvedExpr, ResolvedFunction, @@ -242,6 +243,51 @@ fn resolved_call(name: &str, id: u32, kind: FunctionKind, arg: &str) -> LogicalP LogicalPlan::table(["t"]).project(vec![call]) } +/// A lambda and its variables enter the key: parameter names, the +/// variable's name and identity, and the lambda/variable tags all count. +#[test] +fn lambda_and_its_variables_enter_the_key() { + let var = BoundColumn { + id: AttrId(2), + name: "y".to_owned(), + data_type: DataType::Integer, + nullable: false, + }; + let body = Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(var.clone()))); + let lam = |params: Vec| { + Expr::new(ExprNode::Lambda { + params, + body: Arc::new(body.clone()), + }) + }; + let p = |e: Expr| key(LogicalPlan::table(["t"]).filter(e)); + let base = p(lam(vec!["y".to_owned()])); + assert_ne!(p(lam(vec!["z".to_owned()])), base, "params"); + let renamed = Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(BoundColumn { + id: AttrId(2), + name: "z".to_owned(), + data_type: DataType::Integer, + nullable: false, + }))); + let renamed = Expr::new(ExprNode::Lambda { + params: vec!["z".to_owned()], + body: Arc::new(renamed), + }); + assert_ne!(p(renamed), base, "variable name"); + let reid = Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(BoundColumn { + id: AttrId(3), + ..var.clone() + }))); + let reid = Expr::new(ExprNode::Lambda { + params: vec!["y".to_owned()], + body: Arc::new(reid), + }); + assert_ne!(p(reid), base, "variable identity"); + // A variable is not a column with the same name and identity. + let col = Expr::new(ExprNode::Resolved(ResolvedExpr::Column(var))); + assert_ne!(p(col), base, "variable tag"); +} + /// A function's key is its name, kind and arguments, never its registry /// handle, so a cache shared across builds cannot confuse two functions. #[test] diff --git a/crates/krishiv-plan/src/tests/rewrite.rs b/crates/krishiv-plan/src/tests/rewrite.rs index 565d8c739..2db893762 100644 --- a/crates/krishiv-plan/src/tests/rewrite.rs +++ b/crates/krishiv-plan/src/tests/rewrite.rs @@ -273,6 +273,17 @@ fn exprs() -> Vec<(Expr, usize)> { Expr::new(ExprNode::Resolved(ResolvedExpr::OuterColumn(bound("a")))), 0, ), + ( + Expr::new(ExprNode::Lambda { + params: vec!["y".to_owned()], + body: col("a"), + }), + 1, + ), + ( + Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(bound("a")))), + 0, + ), (resolved_call(vec![col("a")], Some(col("b"))), 2), ( Expr::new(ExprNode::Resolved(ResolvedExpr::Alias { @@ -318,6 +329,21 @@ fn every_expression_slot_is_rewritten_in_order() { } } +/// Leaves expose no slots: rewriting one visits nothing and changes nothing. +#[test] +fn leaves_have_no_slots_to_rewrite() { + for mut e in [ + Expr::column(["a"]), + Expr::new(ExprNode::Resolved(ResolvedExpr::LambdaVar(bound("v")))), + ] { + let before = e.clone(); + let mut visits = 0; + e.for_each_child_mut(&mut |_| visits += 1); + assert_eq!(visits, 0, "{e:?}"); + assert_eq!(e, before); + } +} + #[test] fn expression_resolution() { let resolved = [ diff --git a/crates/krishiv-session/tests/higher_order.rs b/crates/krishiv-session/tests/higher_order.rs index cb3b97493..181c6c0f1 100644 --- a/crates/krishiv-session/tests/higher_order.rs +++ b/crates/krishiv-session/tests/higher_order.rs @@ -161,6 +161,89 @@ fn higher_order_functions_nest() { ); } +#[test] +fn nested_lambdas_capture_enclosing_variables() { + let s = session(); + // The inner body reads the outer call's element variable: every level + // carries what the levels below need. + assert_eq!( + strings( + &s, + "transform(ys, y -> transform(array(1, 2), z -> z + y))", + "FROM t" + ), + [ + Some("[[33, 34], [98, 99]]".to_owned()), + Some("[[78, 79], [-75, -74]]".to_owned()), + Some("[[13, 14]]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); + // The inner body reads the outer call's index variable. + assert_eq!( + strings( + &s, + "transform(ys, (y, i) -> transform(array(10, 2 * 10), z -> z + i))", + "FROM t" + ), + [ + Some("[[10, 20], [11, 21]]".to_owned()), + Some("[[10, 20], [11, 21]]".to_owned()), + Some("[[10, 20]]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); + // An outer column reaches through two levels, beside the element. + assert_eq!( + strings( + &s, + "transform(ys, y -> transform(array(1, 2), z -> z + y + n))", + "FROM t" + ), + [ + Some("[[34, 35], [99, 100]]".to_owned()), + Some("[[80, 81], [-73, -72]]".to_owned()), + Some("[[16, 17]]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); + // Three levels: the middle call carries both its element and the outer + // call's element down to the innermost body. + assert_eq!( + strings( + &s, + "transform(ys, y -> transform(ys, z -> transform(array(1), w -> w + y + z)))", + "FROM t" + ), + [ + Some("[[[65], [130]], [[130], [195]]]".to_owned()), + Some("[[[155], [2]], [[2], [-151]]]".to_owned()), + Some("[[[25]]]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); + // Shadowing still binds the innermost variable: the inner `y` is its + // own element, not the outer call's. + assert_eq!( + strings( + &s, + "transform(ys, y -> transform(array(100), y -> y + 1))", + "FROM t" + ), + [ + Some("[[101], [101]]".to_owned()), + Some("[[101], [101]]".to_owned()), + Some("[[101]]".to_owned()), + None, + Some("[]".to_owned()), + ] + ); +} + #[test] fn filter_keeps_true_elements() { let s = session(); @@ -233,6 +316,62 @@ fn exists_and_forall_fold_the_marks() { ); } +#[test] +fn higher_order_functions_report_bad_arguments() { + let s = session(); + // Every higher-order call takes the array and the lambda. + for name in ["transform", "filter", "exists", "forall"] { + let e = error(&s, &format!("SELECT {name}(ys) FROM t")); + assert_eq!(e.error_class(), ErrorClass::WrongNumArgsWithoutSuggestion); + assert!(e.to_string().contains(&format!("`{name}`")), "{e}"); + } + // The array argument needs `ARRAY`, quoting the call as Spark does. + for name in ["transform", "filter", "exists", "forall"] { + let e = error(&s, &format!("SELECT {name}(1, x -> TRUE)")); + assert_eq!( + e.error_class(), + ErrorClass::DatatypeMismatchUnexpectedInputType, + "{name}" + ); + assert_eq!( + e.to_string(), + format!( + "[DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE] Cannot resolve \ + \"{name}(1, lambdafunction(true, x))\" due to data type mismatch: \ + The first parameter requires the \"ARRAY\" type, \ + however \"1\" has the type \"INT\". SQLSTATE: 42K09" + ) + ); + } +} + +#[test] +fn transform_keeps_null_elements() { + let s = session(); + assert_eq!( + strings(&s, "transform(array(1, NULL, 3), x -> x)", ""), + [Some("[1, null, 3]".to_owned())] + ); + assert_eq!( + strings(&s, "transform(array(1, NULL, 3), (x, i) -> i)", ""), + [Some("[0, 1, 2]".to_owned())] + ); +} + +#[test] +fn lambdas_outside_argument_position_are_rejected() { + let s = session(); + // A lambda under a cast is no higher-order call's argument (its body + // binds on its own, so the lambda itself is what fails). + let e = error(&s, "SELECT CAST((x -> 1) AS STRING)"); + assert_eq!(e.error_class(), ErrorClass::KrishivUnsupportedFeature); + assert!( + e.to_string() + .contains("lambda functions outside a higher-order function"), + "{e}" + ); +} + #[test] fn array_builds_lists() { let s = session(); diff --git a/crates/krishiv-sql/src/lower.rs b/crates/krishiv-sql/src/lower.rs index 62e9582e9..c6134c679 100644 --- a/crates/krishiv-sql/src/lower.rs +++ b/crates/krishiv-sql/src/lower.rs @@ -1578,7 +1578,12 @@ impl Lowerer { ExprKind::Lambda { params, body } => { let params = params.iter().map(|p| p.value.clone()).collect(); let body = self.arg(body)?; - self.ex(ExprNode::Lambda { params, body }, sp) + self.ex( + IrExpr::lambda(params, Arc::unwrap_or_clone(body)) + .node + .clone(), + sp, + ) } ExprKind::Row(_) | ExprKind::Struct(_) => { return Err(unsupported("row and struct constructors", sp)); diff --git a/crates/krishiv-testkit/src/golden/session_engine.rs b/crates/krishiv-testkit/src/golden/session_engine.rs index 9a1334418..bad0e8644 100644 --- a/crates/krishiv-testkit/src/golden/session_engine.rs +++ b/crates/krishiv-testkit/src/golden/session_engine.rs @@ -380,26 +380,23 @@ fn list_cells( row: usize, element: &krishiv_types::ArrayType, ) -> Result, EngineError> { + use arrow_buffer::ArrowNativeType as _; + // Offsets are non-negative by construction (`OffsetBuffer`) and no + // larger than the values' length (checked there), so they fit. let (start, stop, values) = match col.data_type() { ArrowType::List(_) => { let list = col.as_list::(); ( - usize::try_from(list.value_offsets()[row]).map_err(|_| { - harness_error("a nested list with a negative offset".to_owned()) - })?, - usize::try_from(list.value_offsets()[row + 1]).map_err(|_| { - harness_error("a nested list with a negative offset".to_owned()) - })?, + list.value_offsets()[row].as_usize(), + list.value_offsets()[row + 1].as_usize(), Arc::clone(list.values()), ) } ArrowType::LargeList(_) => { let list = col.as_list::(); ( - usize::try_from(list.value_offsets()[row]) - .map_err(|_| harness_error("a nested list with a bad offset".to_owned()))?, - usize::try_from(list.value_offsets()[row + 1]) - .map_err(|_| harness_error("a nested list with a bad offset".to_owned()))?, + list.value_offsets()[row].as_usize(), + list.value_offsets()[row + 1].as_usize(), Arc::clone(list.values()), ) } @@ -418,31 +415,22 @@ fn list_cells( /// The map at `row` of `col` as key/value cells in storage order (the /// renderer sorts them as Spark does). fn map_cell(col: &ArrayRef, row: usize, map: &krishiv_types::MapType) -> Result { - let ArrowType::Map(entries, _) = col.data_type() else { + use arrow_buffer::ArrowNativeType as _; + let ArrowType::Map(..) = col.data_type() else { return Err(harness_error(format!( "Arrow type {} for {}", col.data_type(), DataType::Map(Arc::new(map.clone())).catalog_string() ))); }; - let ArrowType::Struct(kv) = entries.data_type() else { - return Err(harness_error(format!( - "Arrow map entries {}", - entries.data_type() - ))); - }; - if kv.len() != 2 { - return Err(harness_error(format!( - "Arrow map entries {}", - entries.data_type() - ))); - } + // A map's entries are a struct of its keys and values by construction + // (`MapArray`), so no shape check repeats here. let entries = col.as_map(); + // Offsets are non-negative by construction (`OffsetBuffer`) and no + // larger than the entries' length (checked there), so they fit. let (start, stop) = ( - usize::try_from(entries.value_offsets()[row]) - .map_err(|_| harness_error("a nested map with a negative offset".to_owned()))?, - usize::try_from(entries.value_offsets()[row + 1]) - .map_err(|_| harness_error("a nested map with a negative offset".to_owned()))?, + entries.value_offsets()[row].as_usize(), + entries.value_offsets()[row + 1].as_usize(), ); let keys = entries.keys(); let values = entries.values(); @@ -1069,4 +1057,338 @@ mod tests { assert!(fixture_batch(&nested).map_err(err)?.is_none()); Ok(()) } + + fn list_col(offsets: Vec, values: Vec>) -> ArrayRef { + use arrow_array::{Int32Array, ListArray}; + use arrow_buffer::{OffsetBuffer, ScalarBuffer}; + use arrow_schema::Field; + Arc::new(ListArray::new( + Arc::new(Field::new( + "element", + ArrowType::Int32, + values.iter().any(Option::is_none), + )), + OffsetBuffer::new(ScalarBuffer::from(offsets)), + Arc::new(Int32Array::from(values)), + None, + )) + } + + fn int_array_element() -> krishiv_types::ArrayType { + krishiv_types::ArrayType::new(krishiv_types::DataType::Integer, true) + } + + #[test] + fn nested_lists_render_their_elements() -> R { + use arrow_array::Int32Array; + // `[[1, NULL], [], [3]]`. + let col = list_col(vec![0, 2, 2, 3], vec![Some(1), None, Some(3)]); + let element = int_array_element(); + assert_eq!( + list_cells(&col, 0, &element).map_err(err)?, + vec![Cell::Int(1), Cell::Null] + ); + assert_eq!(list_cells(&col, 1, &element).map_err(err)?, vec![]); + assert_eq!( + list_cells(&col, 2, &element).map_err(err)?, + vec![Cell::Int(3)] + ); + // A column that holds no list at all is a harness error. + let ints: ArrayRef = Arc::new(Int32Array::from(vec![1])); + let got = list_cells(&ints, 0, &element).unwrap_err(); + assert!(got.message.contains("Arrow type Int32"), "{}", got.message); + Ok(()) + } + + #[test] + fn large_lists_render_like_lists() -> R { + use arrow_array::{Int32Array, LargeListArray}; + use arrow_buffer::{OffsetBuffer, ScalarBuffer}; + use arrow_schema::Field; + let values: ArrayRef = Arc::new(Int32Array::from(vec![Some(4), Some(5)])); + let col: ArrayRef = Arc::new(LargeListArray::new( + Arc::new(Field::new("element", ArrowType::Int32, false)), + OffsetBuffer::new(ScalarBuffer::from(vec![0_i64, 2])), + values, + None, + )); + assert_eq!( + list_cells(&col, 0, &int_array_element()).map_err(err)?, + vec![Cell::Int(4), Cell::Int(5)] + ); + // A nested list of lists recurses. + let inner = list_col(vec![0, 2, 3], vec![Some(1), None, Some(3)]); + let nested: ArrayRef = Arc::new(arrow_array::ListArray::new( + Arc::new(Field::new( + "element", + ArrowType::List(Arc::new(Field::new("element", ArrowType::Int32, true))), + true, + )), + OffsetBuffer::new(ScalarBuffer::from(vec![0, 2])), + inner, + None, + )); + let lists = + krishiv_types::ArrayType::new(DataType::Array(Arc::new(int_array_element())), true); + assert_eq!( + list_cells(&nested, 0, &lists).map_err(err)?, + vec![ + Cell::Array(vec![Cell::Int(1), Cell::Null]), + Cell::Array(vec![Cell::Int(3)]), + ] + ); + Ok(()) + } + + #[test] + fn nested_scalars_render_by_spark_type() -> R { + use arrow_array::{ + BinaryArray, BooleanArray, Date32Array, Decimal128Array, Float32Array, Float64Array, + Int8Array, Int16Array, Int32Array, Int64Array, LargeStringArray, StringArray, + StringViewArray, TimestampMicrosecondArray, + }; + let cell = |col: ArrayRef, ty: DataType| nested_cell(&col, 0, &ty).map_err(err); + let int = |v: Vec>| -> ArrayRef { Arc::new(Int32Array::from(v)) }; + // A NULL row is NULL whatever the type; an untyped NULL type is NULL + // even over a non-null row. + assert_eq!(cell(int(vec![None]), DataType::Integer)?, Cell::Null); + assert_eq!(cell(int(vec![Some(7)]), DataType::Null)?, Cell::Null); + assert_eq!( + cell(Arc::new(BooleanArray::from(vec![true])), DataType::Boolean)?, + Cell::Bool(true) + ); + assert_eq!( + cell(Arc::new(Int8Array::from(vec![-3])), DataType::Byte)?, + Cell::Int(-3) + ); + assert_eq!( + cell(Arc::new(Int16Array::from(vec![-300])), DataType::Short)?, + Cell::Int(-300) + ); + assert_eq!(cell(int(vec![Some(7)]), DataType::Integer)?, Cell::Int(7)); + assert_eq!( + cell(Arc::new(Int64Array::from(vec![8])), DataType::Long)?, + Cell::Int(8) + ); + assert_eq!( + cell(Arc::new(Float32Array::from(vec![1.5])), DataType::Float)?, + Cell::Float(1.5) + ); + assert_eq!( + cell(Arc::new(Float64Array::from(vec![2.5])), DataType::Double)?, + Cell::Double(2.5) + ); + let dec: ArrayRef = Arc::new( + Decimal128Array::from(vec![150]) + .with_precision_and_scale(5, 2) + .map_err(|e| format!("decimal: {e}"))?, + ); + assert_eq!( + cell( + dec, + DataType::Decimal( + krishiv_types::DecimalType::try_new(5, 2).map_err(|e| format!("{e:?}"))? + ) + )?, + Cell::Decimal(150, 2) + ); + assert_eq!( + cell(Arc::new(StringArray::from(vec!["a"])), DataType::String)?, + Cell::Str("a".into()) + ); + assert_eq!( + cell( + Arc::new(LargeStringArray::from(vec!["b"])), + DataType::String + )?, + Cell::Str("b".into()) + ); + assert_eq!( + cell(Arc::new(StringViewArray::from(vec!["c"])), DataType::String)?, + Cell::Str("c".into()) + ); + assert_eq!( + cell(Arc::new(Date32Array::from(vec![1])), DataType::Date)?, + Cell::Date(1) + ); + assert_eq!( + cell( + Arc::new(TimestampMicrosecondArray::from(vec![1_000_000])), + DataType::Timestamp + )?, + Cell::Timestamp(1_000_000) + ); + assert_eq!( + cell( + Arc::new(TimestampMicrosecondArray::from(vec![2_000_000])), + DataType::TimestampNtz + )?, + Cell::TimestampNtz(2_000_000) + ); + // A nested `binary` has no cell: the harness reports the mismatch. + let binary: ArrayRef = Arc::new(BinaryArray::from(vec![&b"a"[..]])); + let got = nested_cell(&binary, 0, &DataType::Binary).unwrap_err(); + assert!(got.message.contains("Arrow type Binary"), "{}", got.message); + // So does any other Arrow/value mismatch. + let got = nested_cell(&int(vec![Some(1)]), 0, &DataType::String).unwrap_err(); + assert!( + got.message.contains("Arrow type Int32 for string"), + "{}", + got.message + ); + Ok(()) + } + + #[test] + fn nested_maps_render_key_value_cells() -> R { + use arrow_array::{Int32Array, MapArray, StringArray, StructArray}; + use arrow_buffer::{OffsetBuffer, ScalarBuffer}; + use arrow_schema::Field; + let keys: ArrayRef = Arc::new(StringArray::from(vec!["k1", "k2"])); + let values: ArrayRef = Arc::new(Int32Array::from(vec![Some(1), None])); + let entries = StructArray::new( + vec![ + Field::new("key", ArrowType::Utf8, false), + Field::new("value", ArrowType::Int32, true), + ] + .into(), + vec![keys, values], + None, + ); + let map_ty = krishiv_types::MapType::new(DataType::String, DataType::Integer, true); + let field = Field::new("entries", entries.data_type().clone(), false); + let col: ArrayRef = Arc::new(MapArray::new( + Arc::new(field), + OffsetBuffer::new(ScalarBuffer::from(vec![0, 2])), + entries, + None, + false, + )); + assert_eq!( + map_cell(&col, 0, &map_ty).map_err(err)?, + Cell::Map(vec![ + (Cell::Str("k1".into()), Cell::Int(1)), + (Cell::Str("k2".into()), Cell::Null), + ]) + ); + assert_eq!( + arrow_cell(&col, 0, &DataType::Map(Arc::new(map_ty.clone()))).map_err(err)?, + Cell::Map(vec![ + (Cell::Str("k1".into()), Cell::Int(1)), + (Cell::Str("k2".into()), Cell::Null), + ]) + ); + assert_eq!( + nested_cell(&col, 0, &DataType::Map(Arc::new(map_ty))).map_err(err)?, + Cell::Map(vec![ + (Cell::Str("k1".into()), Cell::Int(1)), + (Cell::Str("k2".into()), Cell::Null), + ]) + ); + // A column that holds no map at all is a harness error. + let ints: ArrayRef = Arc::new(Int32Array::from(vec![1])); + let bad = krishiv_types::MapType::new(DataType::String, DataType::Integer, false); + let got = map_cell(&ints, 0, &bad).unwrap_err(); + assert!(got.message.contains("Arrow type Int32"), "{}", got.message); + Ok(()) + } + + #[test] + fn nested_structs_render_named_fields() -> R { + use arrow_array::{Int32Array, StringArray, StructArray}; + use arrow_schema::Field; + let struct_ty = krishiv_types::StructType::new([ + krishiv_types::StructField::new("a", DataType::Integer, true), + krishiv_types::StructField::new("s", DataType::String, true), + ]); + let fields: arrow_schema::Fields = vec![ + Field::new("a", ArrowType::Int32, true), + Field::new("s", ArrowType::Utf8, true), + ] + .into(); + let col: ArrayRef = Arc::new(StructArray::new( + fields, + vec![ + Arc::new(Int32Array::from(vec![Some(1), None])) as ArrayRef, + Arc::new(StringArray::from(vec![Some("x"), None])) as ArrayRef, + ], + None, + )); + assert_eq!( + struct_cell(&col, 0, &struct_ty).map_err(err)?, + Cell::Struct(vec![ + ("a".to_owned(), Cell::Int(1)), + ("s".to_owned(), Cell::Str("x".into())), + ]) + ); + assert_eq!( + struct_cell(&col, 1, &struct_ty).map_err(err)?, + Cell::Struct(vec![ + ("a".to_owned(), Cell::Null), + ("s".to_owned(), Cell::Null), + ]) + ); + assert_eq!( + arrow_cell(&col, 0, &DataType::Struct(struct_ty.clone())).map_err(err)?, + Cell::Struct(vec![ + ("a".to_owned(), Cell::Int(1)), + ("s".to_owned(), Cell::Str("x".into())), + ]) + ); + assert_eq!( + nested_cell(&col, 0, &DataType::Struct(struct_ty.clone())).map_err(err)?, + Cell::Struct(vec![ + ("a".to_owned(), Cell::Int(1)), + ("s".to_owned(), Cell::Str("x".into())), + ]) + ); + // A column that holds no struct, and a struct of another shape, are + // harness errors. + let ints: ArrayRef = Arc::new(Int32Array::from(vec![1])); + let got = struct_cell(&ints, 0, &struct_ty).unwrap_err(); + assert!(got.message.contains("Arrow type Int32"), "{}", got.message); + let narrow = krishiv_types::StructType::new([krishiv_types::StructField::new( + "a", + DataType::Integer, + true, + )]); + let got = struct_cell(&col, 0, &narrow).unwrap_err(); + assert!(got.message.contains("Arrow struct"), "{}", got.message); + Ok(()) + } + + #[test] + fn arrow_cell_reports_type_mismatches() -> R { + use arrow_array::{BooleanArray, Int32Array, LargeBinaryArray}; + // A value of another Arrow type is a harness error naming both sides. + let bools: ArrayRef = Arc::new(BooleanArray::from(vec![true])); + let got = arrow_cell(&bools, 0, &DataType::Integer).unwrap_err(); + assert!( + got.message.contains("Arrow type Boolean for int"), + "{}", + got.message + ); + // A `STRING` over a column with no bytes to read has no cell, and + // neither does a `BINARY` over a non-binary column. + let ints: ArrayRef = Arc::new(Int32Array::from(vec![1])); + let got = arrow_cell(&ints, 0, &DataType::String).unwrap_err(); + assert!( + got.message.contains("Arrow type Int32 for string"), + "{}", + got.message + ); + let got = arrow_cell(&ints, 0, &DataType::Binary).unwrap_err(); + assert!( + got.message.contains("Arrow type Int32 for binary"), + "{}", + got.message + ); + // Every binary carrier reads its bytes. + let large: ArrayRef = Arc::new(LargeBinaryArray::from(vec![&b"ab"[..]])); + assert_eq!( + arrow_cell(&large, 0, &DataType::Binary).map_err(err)?, + Cell::Binary(b"ab".to_vec()) + ); + Ok(()) + } } From da79fcd763d11a3ecf9dcf802532efb14f807823 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Mon, 26 Oct 2026 17:19:09 +0100 Subject: [PATCH 5/7] test: refresh the type-coercion manifest after the merge with main Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- .../typeCoercion/native/mapZipWith.json | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json b/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json index 15ec1ed2f..65ece7641 100644 --- a/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json +++ b/tests/fixtures/analysis/type-coercion/typeCoercion/native/mapZipWith.json @@ -2,35 +2,35 @@ "entries": [ { "query": "SELECT map_zip_with(array_map1, array_map2, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(decimal_map1, decimal_map2, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(decimal_map1, double_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(decimal_map1, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(decimal_map1, string_map4, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(decimal_map2, double_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(decimal_map2, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(double_map, float_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(float_infinity_map1, float_infinity_map2, (k, v1, v2) -> (v1, v2)) m\nFROM various_maps", @@ -46,31 +46,31 @@ }, { "query": "SELECT map_zip_with(int_map, bigint_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(smallint_map, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(string_map1, int_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(string_map2, date_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(struct_map1, struct_map2, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(timestamp_map, string_map3, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" }, { "query": "SELECT map_zip_with(tinyint_map, smallint_map, (k, v1, v2) -> struct(k, v1, v2)) m\nFROM various_maps", - "reason": "KRISHIV_UNSUPPORTED_FEATURE: row and struct constructors" + "reason": "KRISHIV_UNSUPPORTED_FEATURE: function map_zip_with" } ], "file": "typeCoercion/native/mapZipWith", From 440e3565a550a6510661b1bf6b70aac0c66ceec2 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Mon, 26 Oct 2026 20:29:14 +0100 Subject: [PATCH 6/7] test(kernels): shrink large_offsets_reshape under miri Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- crates/krishiv-kernels/src/list/tests.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/krishiv-kernels/src/list/tests.rs b/crates/krishiv-kernels/src/list/tests.rs index fde5952bc..fc1b8d0bf 100644 --- a/crates/krishiv-kernels/src/list/tests.rs +++ b/crates/krishiv-kernels/src/list/tests.rs @@ -244,7 +244,8 @@ fn nested_lists_reshape() { #[test] fn large_offsets_reshape() { // 100,000 single-element lists: the reshape is offset arithmetic. - let n = 100_000usize; + // Miri interprets every element, so it checks a reduced case. + let n = if cfg!(miri) { 1_000usize } else { 100_000 }; let values: ArrayRef = Arc::new(Int32Array::from(vec![1; n])); let input = ListArray::new( field(), From 3b61431b1470374eafe8f090eddac9a774522129 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Mon, 26 Oct 2026 20:35:19 +0100 Subject: [PATCH 7/7] fix: pass the partition through higher-order evaluation after the merge with main Main added a partition argument to PhysExpr::eval and EvalEnv::seed_salt; the lambda evaluator forwards the caller's partition to its array and body. The registry matrix manifest drops the rand/randn/random/randstr/typeof/uniform mismatches that array() support resolves. Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- crates/krishiv-exec/src/planner/eval/hof.rs | 21 ++++++------ .../analysis/registry-matrix/rand.json | 8 ----- .../analysis/registry-matrix/randn.json | 8 ----- .../analysis/registry-matrix/random.json | 8 ----- .../analysis/registry-matrix/randstr.json | 16 ---------- .../analysis/registry-matrix/typeof.json | 32 ------------------- .../analysis/registry-matrix/uniform.json | 24 -------------- 7 files changed, 11 insertions(+), 106 deletions(-) diff --git a/crates/krishiv-exec/src/planner/eval/hof.rs b/crates/krishiv-exec/src/planner/eval/hof.rs index bdc2aaa96..97f07efa7 100644 --- a/crates/krishiv-exec/src/planner/eval/hof.rs +++ b/crates/krishiv-exec/src/planner/eval/hof.rs @@ -245,9 +245,9 @@ impl PhysExpr for Call { self.nullable } - fn eval(&self, batch: &RecordBatch) -> Result { + fn eval(&self, batch: &RecordBatch, partition: u32) -> Result { let rows = batch.num_rows(); - let array = self.array.eval(batch)?.into_array(rows)?; + let array = self.array.eval(batch, partition)?.into_array(rows)?; if array.len() != rows { return Err(internal("a higher-order array of the wrong row count")); } @@ -357,7 +357,7 @@ impl PhysExpr for Call { ) .map_err(|e| internal(&e.to_string()))? }; - let body = self.body.eval(&flat)?.into_array(total)?; + let body = self.body.eval(&flat, partition)?.into_array(total)?; if body.len() != total { return Err(internal("a higher-order body of the wrong row count")); } @@ -434,7 +434,7 @@ mod tests { self.nullable } - fn eval(&self, _batch: &RecordBatch) -> Result { + fn eval(&self, _batch: &RecordBatch, _partition: u32) -> Result { Ok(Value::Array(Arc::clone(&self.array))) } } @@ -447,6 +447,7 @@ mod tests { kernels: KernelCtx::new(), query_start_micros: 0, user: Arc::from("test"), + seed_salt: Arc::new(std::sync::atomic::AtomicU64::new(0)), } } @@ -569,7 +570,7 @@ mod tests { Arc::new(Int32Array::from(vec![1, 2])), ArrowType::Boolean, ); - let err = c.eval(&batch(2)).unwrap_err(); + let err = c.eval(&batch(2), 0).unwrap_err(); assert!( err.to_string() .contains("a higher-order array of the wrong row count"), @@ -582,7 +583,7 @@ mod tests { Arc::new(Int32Array::from(vec![1, 2, 3])), ArrowType::Boolean, ); - let err = c.eval(&batch(1)).unwrap_err(); + let err = c.eval(&batch(1), 0).unwrap_err(); assert!( err.to_string() .contains("a higher-order body of the wrong row count"), @@ -598,7 +599,7 @@ mod tests { Arc::new(Int32Array::from(vec![7, 8])), ArrowType::Int32, ); - let err = c.eval(&batch(1)).unwrap_err(); + let err = c.eval(&batch(1), 0).unwrap_err(); assert!( err.to_string() .contains("a higher-order call over a non-list"), @@ -614,7 +615,7 @@ mod tests { Arc::new(BooleanArray::from(vec![true, false])), ArrowType::Boolean, ); - let err = c.eval(&batch(1)).unwrap_err(); + let err = c.eval(&batch(1), 0).unwrap_err(); assert_eq!(err.error_class(), ErrorClass::KrishivUnsupportedFeature); assert!( err.to_string().contains("higher-order function bogus"), @@ -636,7 +637,7 @@ mod tests { ArrowType::List(Arc::new(Field::new("element", ArrowType::Int32, true))), ); c.sources = vec![super::Source::Element]; - let out = c.eval(&batch(1)).unwrap().into_array(1).unwrap(); + let out = c.eval(&batch(1), 0).unwrap().into_array(1).unwrap(); let out = out.as_list::(); assert_eq!(out.len(), 1); assert_eq!(out.value_offsets(), &[0, 1]); @@ -657,7 +658,7 @@ mod tests { Arc::new(Int32Array::from(vec![7, 8])), out, ); - let err = c.eval(&batch(1)).unwrap_err(); + let err = c.eval(&batch(1), 0).unwrap_err(); assert_eq!(err.error_class(), ErrorClass::InternalError); assert!( err.to_string().contains("transform returned List(Int32"), diff --git a/tests/fixtures/analysis/registry-matrix/rand.json b/tests/fixtures/analysis/registry-matrix/rand.json index c92cc4430..610f5ddb6 100644 --- a/tests/fixtures/analysis/registry-matrix/rand.json +++ b/tests/fixtures/analysis/registry-matrix/rand.json @@ -1,13 +1,5 @@ { "entries": [ - { - "id": "rand#114bc082913c/ansi_on", - "reason": "SELECT rand(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "rand#114bc082913c/ansi_off", - "reason": "SELECT rand(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "rand#16b39c8effd3/ansi_on", "reason": "SELECT rand(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/randn.json b/tests/fixtures/analysis/registry-matrix/randn.json index d01eca515..5fcb326f1 100644 --- a/tests/fixtures/analysis/registry-matrix/randn.json +++ b/tests/fixtures/analysis/registry-matrix/randn.json @@ -23,14 +23,6 @@ { "id": "randn#9df340e4c4ed/ansi_off", "reason": "SELECT randn(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "randn#db9474536e6f/ansi_on", - "reason": "SELECT randn(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "randn#db9474536e6f/ansi_off", - "reason": "SELECT randn(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" } ], "format_version": 1, diff --git a/tests/fixtures/analysis/registry-matrix/random.json b/tests/fixtures/analysis/registry-matrix/random.json index 83f5dfa94..dab9bc0cd 100644 --- a/tests/fixtures/analysis/registry-matrix/random.json +++ b/tests/fixtures/analysis/registry-matrix/random.json @@ -16,14 +16,6 @@ "id": "random#73bb8aca50b7/ansi_off", "reason": "SELECT random(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "random#aafd575271fd/ansi_on", - "reason": "SELECT random(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "random#aafd575271fd/ansi_off", - "reason": "SELECT random(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "random#b218d468723d/ansi_on", "reason": "SELECT random(map('a', 1)) | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/randstr.json b/tests/fixtures/analysis/registry-matrix/randstr.json index c38e1ca9d..81e46a666 100644 --- a/tests/fixtures/analysis/registry-matrix/randstr.json +++ b/tests/fixtures/analysis/registry-matrix/randstr.json @@ -16,22 +16,6 @@ "id": "randstr#55df7b2e1334/ansi_off", "reason": "SELECT randstr(3, INTERVAL '1 02:03:04' DAY TO SECOND) AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "randstr#72a2793557e6/ansi_on", - "reason": "SELECT randstr(array(1, 2), 0) AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "randstr#72a2793557e6/ansi_off", - "reason": "SELECT randstr(array(1, 2), 0) AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "randstr#78a2b0d4ee1a/ansi_on", - "reason": "SELECT randstr(3, array(1, 2)) AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "randstr#78a2b0d4ee1a/ansi_off", - "reason": "SELECT randstr(3, array(1, 2)) AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "randstr#9e4c25337d0d/ansi_on", "reason": "SELECT randstr(map('a', 1), 0) AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" diff --git a/tests/fixtures/analysis/registry-matrix/typeof.json b/tests/fixtures/analysis/registry-matrix/typeof.json index 57307746d..fa1942275 100644 --- a/tests/fixtures/analysis/registry-matrix/typeof.json +++ b/tests/fixtures/analysis/registry-matrix/typeof.json @@ -16,38 +16,6 @@ "id": "typeof#85119c3e6111/ansi_off", "reason": "SELECT typeof(INTERVAL '1 02:03:04' DAY TO SECOND) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" }, - { - "id": "typeof#86964662cdab/ansi_on", - "reason": "SELECT typeof(array(1)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "typeof#86964662cdab/ansi_off", - "reason": "SELECT typeof(array(1)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "typeof#8b64929c858b/ansi_on", - "reason": "SELECT typeof(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "typeof#8b64929c858b/ansi_off", - "reason": "SELECT typeof(array(1, 2)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "typeof#94be9d2b4025/ansi_on", - "reason": "SELECT typeof(CAST(array() AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "typeof#94be9d2b4025/ansi_off", - "reason": "SELECT typeof(CAST(array() AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "typeof#bea7c4b2a1ca/ansi_on", - "reason": "SELECT typeof(CAST(array(NULL) AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, - { - "id": "typeof#bea7c4b2a1ca/ansi_off", - "reason": "SELECT typeof(CAST(array(NULL) AS array)) | KRISHIV_UNSUPPORTED_FEATURE: function array" - }, { "id": "typeof#ef1847dcc457/ansi_on", "reason": "SELECT typeof(INTERVAL '1-2' YEAR TO MONTH) | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals" diff --git a/tests/fixtures/analysis/registry-matrix/uniform.json b/tests/fixtures/analysis/registry-matrix/uniform.json index 05efb925d..900704b81 100644 --- a/tests/fixtures/analysis/registry-matrix/uniform.json +++ b/tests/fixtures/analysis/registry-matrix/uniform.json @@ -16,14 +16,6 @@ "id": "uniform#1e99715e4fd3/ansi_off", "reason": "SELECT uniform(10, INTERVAL '1 02:03:04' DAY TO SECOND, 0) > 0 AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "uniform#30c2e2b398e9/ansi_on", - "reason": "SELECT uniform(array(1, 2), 20, 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "uniform#30c2e2b398e9/ansi_off", - "reason": "SELECT uniform(array(1, 2), 20, 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "uniform#310b01a5b4ae/ansi_on", "reason": "SELECT uniform(10, INTERVAL '1-2' YEAR TO MONTH, 0) > 0 AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -56,14 +48,6 @@ "id": "uniform#5656d353ced6/ansi_off", "reason": "SELECT uniform(INTERVAL '1-2' YEAR TO MONTH, 20, 0) > 0 AS result | parse: KRISHIV_UNSUPPORTED_FEATURE: INTERVAL literals where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" }, - { - "id": "uniform#5ff5470f6623/ansi_on", - "reason": "SELECT uniform(10, 20, array(1, 2)) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "uniform#5ff5470f6623/ansi_off", - "reason": "SELECT uniform(10, 20, array(1, 2)) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "uniform#681f70cb51f1/ansi_on", "reason": "SELECT uniform(map('a', 1), 20, 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" @@ -112,14 +96,6 @@ "id": "uniform#ab6b99e0333b/ansi_off", "reason": "SELECT uniform(10, NULL, 0) > 0 AS result | boolean where Spark has boolean not null" }, - { - "id": "uniform#ac2a6eb487eb/ansi_on", - "reason": "SELECT uniform(10, array(1, 2), 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, - { - "id": "uniform#ac2a6eb487eb/ansi_off", - "reason": "SELECT uniform(10, array(1, 2), 0) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function array where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE" - }, { "id": "uniform#d54a4a610339/ansi_on", "reason": "SELECT uniform(10, 20, map('a', 1)) > 0 AS result | KRISHIV_UNSUPPORTED_FEATURE: function map where Spark has DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE"