From 25516226bb814202af549c8ce7655d4d998039e6 Mon Sep 17 00:00:00 2001 From: techysneha14 <343708768+shehatathe@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:17:22 +0200 Subject: [PATCH 1/8] fix(kernels): try_cast parses integral strings as ANSI does TRY_CAST('1.23' AS INT) is NULL in Spark 4.2 (try_cast.sql): try_cast uses the exact (toLongExact) parser, so a fraction is malformed rather than dropped. The kernel used the legacy parser for Try mode. Signed-off-by: techysneha14 <343708768+shehatathe@users.noreply.github.com> --- crates/krishiv-kernels/src/cast.rs | 5 +++-- crates/krishiv-kernels/tests/casts.rs | 9 ++++++++- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/crates/krishiv-kernels/src/cast.rs b/crates/krishiv-kernels/src/cast.rs index abe596787..2633bafaf 100644 --- a/crates/krishiv-kernels/src/cast.rs +++ b/crates/krishiv-kernels/src/cast.rs @@ -578,8 +578,9 @@ pub fn cast( ($o:ty, $t:ty) => {{ let s = input.as_string::<$o>(); let out = map_rows::<$t>(input, |i| { - // Out of the target's range is malformed too (Spark's `toInt`). - let v = text::parse_integral(s.value(i).as_bytes(), mode == CastMode::Ansi) + // Out of the target's range is malformed too (Spark's `toInt`); + // `try_cast` parses as ANSI does (`toLongExact`), so `'1.5'` is NULL. + let v = text::parse_integral(s.value(i).as_bytes(), mode != CastMode::Legacy) .and_then(|v| match <$t as SparkIntegral>::narrow(i128::from(v)) { (n, false) => Some(n), (_, true) => None, diff --git a/crates/krishiv-kernels/tests/casts.rs b/crates/krishiv-kernels/tests/casts.rs index 05c075a72..2774f8350 100644 --- a/crates/krishiv-kernels/tests/casts.rs +++ b/crates/krishiv-kernels/tests/casts.rs @@ -123,7 +123,14 @@ fn string_to_numbers_match_spark() { one(s("it's"), int.clone(), Ansi), invalid("'it\\'s'", "INT") ); - assert_eq!(one(s("abc"), int, Try), "NULL"); + assert_eq!(one(s("abc"), int.clone(), Try), "NULL"); + // `try_cast` parses as ANSI does: a fraction is malformed, not dropped + // (Spark 4.2 `try_cast.sql`: `TRY_CAST('1.23' AS int)` is NULL). + for to in [DataType::Int8, int.clone(), DataType::Int64] { + assert_eq!(one(s("1.23"), to.clone(), Try), "NULL"); + assert_eq!(one(s("-4.56"), to, Try), "NULL"); + } + assert_eq!(one(s(" 7 "), int, Try), "7"); assert_eq!( one(s("128"), DataType::Int8, Ansi), invalid("'128'", "TINYINT") From 0ac94e87f2687c45f6e915977dbc78293902ee70 Mon Sep 17 00:00:00 2001 From: techysneha14 <343708768+shehatathe@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:19:19 +0200 Subject: [PATCH 2/8] fix(plan): reject a negative or NULL LIMIT at analysis Spark's checkLimitLikeClause raises INVALID_LIMIT_LIKE_EXPRESSION.IS_NEGATIVE and .IS_NULL for a foldable count; LIMIT -1 used to reach the physical planner as INTERNAL_ERROR (limit.sql). The checks live in their own non-inlined function so the resolver's recursive frame does not grow. Signed-off-by: techysneha14 <343708768+shehatathe@users.noreply.github.com> --- crates/krishiv-plan/src/analyzer/resolve.rs | 46 ++++++++++++++++----- crates/krishiv-sql/tests/analyzer.rs | 26 ++++++++++++ 2 files changed, 62 insertions(+), 10 deletions(-) diff --git a/crates/krishiv-plan/src/analyzer/resolve.rs b/crates/krishiv-plan/src/analyzer/resolve.rs index da70c8c97..8d7e3e9b3 100644 --- a/crates/krishiv-plan/src/analyzer/resolve.rs +++ b/crates/krishiv-plan/src/analyzer/resolve.rs @@ -348,6 +348,41 @@ impl Resolver<'_> { .ok_or_else(|| unsupported("a plan shape", root.origin)) } + /// Spark's `checkLimitLikeClause` on a bound `LIMIT` count: it must be + /// an `INT`, and a foldable count must be neither NULL nor negative. + /// Kept out of the resolver's recursive match so its locals do not + /// grow every frame of a deep plan. + #[inline(never)] + fn check_limit(&self, b: &Bound, origin: Origin) -> Result<(), AnalysisError> { + let expr = || format!("\"{}\"", super::exprs::pretty(&b.shown())); + let name = "limit".to_owned(); + if b.ty.data_type != Some(krishiv_types::DataType::Integer) { + return Err(AnalysisError::new( + krishiv_common::error::InvalidLimitLikeExpressionDataType { + expr: expr(), + name, + data_type: super::coerce::quoted_type(b.ty.data_type.as_ref()), + }, + origin, + )); + } + match super::fold::constant(&b.expr, self.ctx.conf.ansi) { + Some(super::Constant::Null) => Err(AnalysisError::new( + krishiv_common::error::InvalidLimitLikeExpressionIsNull { expr: expr(), name }, + origin, + )), + Some(super::Constant::Integral(v)) if v < 0 => Err(AnalysisError::new( + krishiv_common::error::InvalidLimitLikeExpressionIsNegative { + expr: expr(), + name, + v: v.to_string(), + }, + origin, + )), + _ => Ok(()), + } + } + pub(super) fn child(&self, c: &Arc, env: &Env) -> Result { self.memo .get(&(addr(&*self.rep(c)), env.id)) @@ -580,16 +615,7 @@ impl Resolver<'_> { let c = self.child(input, env)?; let cx = Self::cx(&[], &[], env, "Limit"); let b = self.bind(limit, &cx)?; - if b.ty.data_type != Some(krishiv_types::DataType::Integer) { - return Err(AnalysisError::new( - krishiv_common::error::InvalidLimitLikeExpressionDataType { - expr: format!("\"{}\"", super::exprs::pretty(&b.shown())), - name: "limit".to_owned(), - data_type: super::coerce::quoted_type(b.ty.data_type.as_ref()), - }, - limit.origin, - )); - } + self.check_limit(&b, limit.origin)?; let node = PlanNode::Limit { input: Arc::clone(&c.plan), limit: b.expr, diff --git a/crates/krishiv-sql/tests/analyzer.rs b/crates/krishiv-sql/tests/analyzer.rs index 7108d6fad..98a4b9bfe 100644 --- a/crates/krishiv-sql/tests/analyzer.rs +++ b/crates/krishiv-sql/tests/analyzer.rs @@ -440,3 +440,29 @@ fn repeated_correlation_keys_stay_unique() { check(a.plan.root()); assert!(a.plan.root().to_string().contains("Aggregate [a#3], ")); } + +/// A foldable `LIMIT` that is negative or NULL fails analysis as Spark's +/// `checkLimitLikeClause` does (it used to reach the planner). +#[test] +fn negative_and_null_limits_fail_analysis() { + let g = goldens(); + let err = |sql: &str| { + analyze(&g, sql, ResolutionConf::default()) + .unwrap_err() + .error + }; + let e = err("SELECT a FROM t LIMIT -1"); + assert_eq!( + e.error_class().name(), + "INVALID_LIMIT_LIKE_EXPRESSION.IS_NEGATIVE" + ); + assert_eq!(e.sql_state(), Some("42K0E")); + assert!(e.message().contains("\"-1\""), "{}", e.message()); + assert!(e.message().contains("but got -1"), "{}", e.message()); + let e = err("SELECT a FROM t LIMIT CAST(NULL AS INT)"); + assert_eq!( + e.error_class().name(), + "INVALID_LIMIT_LIKE_EXPRESSION.IS_NULL" + ); + assert!(analyze(&g, "SELECT a FROM t LIMIT 0", ResolutionConf::default()).is_ok()); +} From 4fd3480c5625b799612e83a4d8a05890fc40ca1b Mon Sep 17 00:00:00 2001 From: techysneha14 <343708768+shehatathe@users.noreply.github.com> Date: Thu, 22 Oct 2026 15:19:24 +0200 Subject: [PATCH 3/8] feat(testkit): golden run through the session, frozen baseline and ratchet (P2-T100a) - golden::session_engine: an Engine over krishiv-session (fresh session per run with the file's configs and fixture tables; SET/RESET mirrored into the session; rows rendered by golden::cell from the result's Spark types; sortedness from the analyzed plan; per-statement time limit). - The runner records each statement's outcome and why it failed. - tests/spark-golden/known-failures.json: every statement of the Spark 4.2 suite that does not pass, with a category (unsupported feature with its plan task, divergence with ADR 0023, or bug with its owner) and the classification rules (golden::classify) used to seed new entries. - golden_ratchet test: the full suite must fail exactly the listed statements; a new failure fails CI and a listed statement that passes must be removed. golden-report --ratchet check|update. - The file-level exclusion manifest is frozen (no exclusions). First full run: parse 14025/18827, negative 629/3857, result 966/15363. Signed-off-by: techysneha14 <343708768+shehatathe@users.noreply.github.com> --- Cargo.lock | 1 + crates/krishiv-testkit/CLAUDE.md | 7 +- crates/krishiv-testkit/Cargo.toml | 1 + .../krishiv-testkit/src/bin/golden-report.rs | 94 +- crates/krishiv-testkit/src/golden/classify.rs | 413 ++++++++ .../src/golden/known_failures.rs | 959 ++++++++++++++++++ crates/krishiv-testkit/src/golden/mod.rs | 3 + crates/krishiv-testkit/src/golden/report.rs | 67 ++ crates/krishiv-testkit/src/golden/run.rs | 266 ++++- .../src/golden/session_engine.rs | 809 +++++++++++++++ .../krishiv-testkit/tests/golden_ratchet.rs | 33 + crates/krishiv-testkit/tests/golden_report.rs | 38 + tests/spark-golden/exclusions.json | 2 +- tests/spark-golden/known-failures.json | 815 +++++++++++++++ xtask/src/main.rs | 2 +- 15 files changed, 3457 insertions(+), 53 deletions(-) create mode 100644 crates/krishiv-testkit/src/golden/classify.rs create mode 100644 crates/krishiv-testkit/src/golden/known_failures.rs create mode 100644 crates/krishiv-testkit/src/golden/session_engine.rs create mode 100644 crates/krishiv-testkit/tests/golden_ratchet.rs create mode 100644 tests/spark-golden/known-failures.json diff --git a/Cargo.lock b/Cargo.lock index 380b2e69d..60b702afe 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1729,6 +1729,7 @@ dependencies = [ "krishiv-kernels", "krishiv-memory", "krishiv-plan", + "krishiv-session", "krishiv-sql", "krishiv-types", "object_store", diff --git a/crates/krishiv-testkit/CLAUDE.md b/crates/krishiv-testkit/CLAUDE.md index 33f7cc101..f5d97d1ea 100644 --- a/crates/krishiv-testkit/CLAUDE.md +++ b/crates/krishiv-testkit/CLAUDE.md @@ -8,7 +8,12 @@ Conformance harness: Spark `hash()`/`xxhash64()` golden fixtures (`tests/fixture the `SQLQueryTestSuite` golden runner over `tests/spark-golden//` (`.sql.out` parser, `Engine` trait, three-number report, exclusion manifest `tests/spark-golden/exclusions.json`; `cargo xtask golden` writes `target/golden-report.json`; `--engine sql-parse` measures the `krishiv-sql` parser on the DQL statements, -`golden::sql_parse`; no CI ratchet yet), the batch == bounded-stream invariant +`golden::sql_parse`; `--engine session` runs every statement through `krishiv-session`, `golden::session_engine`), +the frozen statement-level baseline `tests/spark-golden/known-failures.json` (`golden::known_failures`: every failing +statement with a category — unsupported feature with its plan task, divergence with ADR 0023, or bug with its owner; +classification rules in the same file, `golden::classify`) and its CI ratchet (test `golden_ratchet`: a newly failing +statement fails, a listed statement that passes must be removed; refresh with +`cargo run -p krishiv-testkit --bin golden-report -- --engine session --ratchet update`), the batch == bounded-stream invariant harness, a sqllogictest runner over `tests/sqllogictest/`, and the Spark function matrix (P2-T106a): `tests/fixtures/spark-/function-matrix/` (generated by `tests/scripts/gen_function_matrix.py` against the Spark container), loaded by `fn_matrix`, with the coverage dashboard from diff --git a/crates/krishiv-testkit/Cargo.toml b/crates/krishiv-testkit/Cargo.toml index 7659e4cba..79ddaefcc 100644 --- a/crates/krishiv-testkit/Cargo.toml +++ b/crates/krishiv-testkit/Cargo.toml @@ -28,6 +28,7 @@ krishiv-memory = { path = "../krishiv-memory" } krishiv-plan = { path = "../krishiv-plan" } object_store = { workspace = true, features = ["fs"] } parquet = { workspace = true, features = ["arrow"] } +krishiv-session = { path = "../krishiv-session", features = ["unstable-ir"] } krishiv-sql = { path = "../krishiv-sql" } krishiv-types = { path = "../krishiv-types" } regex-lite.workspace = true diff --git a/crates/krishiv-testkit/src/bin/golden-report.rs b/crates/krishiv-testkit/src/bin/golden-report.rs index 56d2f43af..c385d4a4b 100644 --- a/crates/krishiv-testkit/src/bin/golden-report.rs +++ b/crates/krishiv-testkit/src/bin/golden-report.rs @@ -2,35 +2,71 @@ //! Runs the Spark `SQLQueryTestSuite` golden files against an engine and writes the report //! (three numbers, per-file denominators, exclusion manifest) as JSON. //! -//! `cargo run -p krishiv-testkit --bin golden-report -- [--tag TAG] [--jdk 17|21] [--manifest FILE] [--out FILE]` -//! (or `cargo xtask golden`). The default engine is the reject-all stub (0/0/0 with the real -//! denominators); `--engine sql-parse` measures the `krishiv-sql` parser on the DQL statements -//! ([`krishiv_testkit::golden::sql_parse`]). +//! `cargo run -p krishiv-testkit --bin golden-report -- [--tag TAG] [--jdk 17|21] [--manifest FILE] +//! [--out FILE] [--engine reject-all|sql-parse|session] [--cases FILE] [--ratchet check|update] +//! [--known-failures FILE]` (or `cargo xtask golden`). +//! +//! * The default engine is the reject-all stub (0/0/0 with the real denominators); +//! `--engine sql-parse` measures the `krishiv-sql` parser on the DQL statements +//! ([`krishiv_testkit::golden::sql_parse`]); `--engine session` runs every statement through +//! `krishiv-session` ([`krishiv_testkit::golden::session_engine`]). +//! * `--cases FILE` writes every statement that did not pass, with why. +//! * `--ratchet check` compares the run with the frozen baseline +//! (`tests/spark-golden/known-failures.json`) and fails on any difference; +//! `--ratchet update` rewrites the baseline: passing statements leave it, new failures are +//! classified by its rules (the command fails, writing nothing, if a failure matches no rule). #![forbid(unsafe_code)] use std::io::Write as _; -use std::path::PathBuf; +use std::path::{Path, PathBuf}; use std::process::ExitCode; +use krishiv_testkit::golden::known_failures::KnownFailures; use krishiv_testkit::golden::manifest::ExclusionManifest; -use krishiv_testkit::golden::run::{RejectAllEngine, run_with}; +use krishiv_testkit::golden::run::{Engine, RejectAllEngine, RunResult, run_with}; +use krishiv_testkit::golden::session_engine::SessionEngine; use krishiv_testkit::golden::sql_parse::{ParseOnlyEngine, in_dql_scope}; use krishiv_testkit::golden::{DEFAULT_TAG, GoldenSet, Jdk, report}; -const USAGE: &str = "usage: golden-report [--tag TAG] [--jdk 17|21] [--manifest FILE] [--out FILE] [--engine reject-all|sql-parse]"; +const USAGE: &str = "usage: golden-report [--tag TAG] [--jdk 17|21] [--manifest FILE] [--out FILE] \ +[--engine reject-all|sql-parse|session] [--cases FILE] [--ratchet check|update] [--known-failures FILE]"; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Ratchet { + Off, + Check, + Update, +} + +fn ratchet( + mode: Ratchet, + path: &Path, + set: &GoldenSet, + result: &RunResult, +) -> Result { + match mode { + Ratchet::Check => KnownFailures::check_file(path, result), + Ratchet::Update => KnownFailures::update_file(path, result, set), + Ratchet::Off => Ok(String::new()), + } +} fn run_cli() -> Result<(), String> { let mut tag = DEFAULT_TAG.to_owned(); let mut manifest_path = ExclusionManifest::default_path(); + let mut known_path = KnownFailures::default_path(); let mut out = None; let mut jdk = Jdk::default(); - let mut sql_parse = false; + let mut engine_name = "reject-all".to_owned(); + let mut cases_out = None; + let mut mode = Ratchet::Off; let mut args = std::env::args().skip(1); while let Some(flag) = args.next() { let value = args.next().ok_or_else(|| USAGE.to_owned())?; match flag.as_str() { "--tag" => tag = value, "--manifest" => manifest_path = PathBuf::from(value), + "--known-failures" => known_path = PathBuf::from(value), "--jdk" => { jdk = match value.as_str() { "17" => Jdk::Java17, @@ -39,43 +75,63 @@ fn run_cli() -> Result<(), String> { } } "--out" => out = Some(PathBuf::from(value)), - "--engine" => { - sql_parse = match value.as_str() { - "reject-all" => false, - "sql-parse" => true, + "--engine" => match value.as_str() { + "reject-all" | "sql-parse" | "session" => engine_name = value, + _ => return Err(USAGE.to_owned()), + }, + "--cases" => cases_out = Some(PathBuf::from(value)), + "--ratchet" => { + mode = match value.as_str() { + "check" => Ratchet::Check, + "update" => Ratchet::Update, _ => return Err(USAGE.to_owned()), } } _ => return Err(USAGE.to_owned()), } } + if mode != Ratchet::Off && engine_name != "session" { + return Err("--ratchet needs --engine session".to_owned()); + } let manifest = ExclusionManifest::load(&manifest_path).map_err(|e| e.to_string())?; let dir = GoldenSet::tag_dir(&tag); let set = GoldenSet::scan_for(&dir, jdk).map_err(|e| format!("{}: {e}", dir.display()))?; - let result = if sql_parse { - run_with( + let result = match engine_name.as_str() { + "sql-parse" => run_with( &mut ParseOnlyEngine::default(), &set, &manifest, &in_dql_scope, - ) - } else { - run_with(&mut RejectAllEngine, &set, &manifest, &|_| true) + ), + "session" => { + let mut engine = SessionEngine::new().map_err(|e| e.message)?; + run_with(&mut engine as &mut dyn Engine, &set, &manifest, &|_| true) + } + _ => run_with(&mut RejectAllEngine, &set, &manifest, &|_| true), } .map_err(|e| e.to_string())?; - let json = report::to_json_string(&report::to_json(&result, &tag, &manifest)) - .map_err(|e| e.to_string())?; let mut stdout = std::io::stdout().lock(); stdout .write_all(report::summary(&result).as_bytes()) .map_err(|e| e.to_string())?; + if let Some(path) = &cases_out { + let text = + report::to_json_string(&report::cases_json(&result)).map_err(|e| e.to_string())?; + std::fs::write(path, text).map_err(|e| format!("{}: {e}", path.display()))?; + } if let Some(path) = out { + let json = report::to_json_string(&report::to_json(&result, &tag, &manifest)) + .map_err(|e| e.to_string())?; if let Some(parent) = path.parent() { std::fs::create_dir_all(parent).map_err(|e| format!("{}: {e}", parent.display()))?; } std::fs::write(&path, json).map_err(|e| format!("{}: {e}", path.display()))?; writeln!(stdout, "report written to {}", path.display()).map_err(|e| e.to_string())?; } + if mode != Ratchet::Off { + let msg = ratchet(mode, &known_path, &set, &result)?; + writeln!(stdout, "{msg}").map_err(|e| e.to_string())?; + } Ok(()) } diff --git a/crates/krishiv-testkit/src/golden/classify.rs b/crates/krishiv-testkit/src/golden/classify.rs new file mode 100644 index 000000000..5af51a8e8 --- /dev/null +++ b/crates/krishiv-testkit/src/golden/classify.rs @@ -0,0 +1,413 @@ +// SPDX-License-Identifier: Apache-2.0 +//! Classification rules for failing golden statements: the first rule that matches a failure +//! names its category in the known-failures baseline ([`super::known_failures`]). +//! +//! A rule is data in the baseline file: +//! +//! ```json +//! {"category": "string-functions", "family": ["string"], "detail": "not supported"} +//! ``` +//! +//! Every condition present must hold: +//! * `command`: the statement is (not) a SQL command, i.e. does (not) start like a query; +//! * `depends`: the statement does (not) mention a name an earlier command of the file creates +//! (`CREATE ... VIEW|TABLE|FUNCTION|VARIABLE name`, `DECLARE name`); +//! * `file`, `query`, `detail`: regular expressions (`regex-lite` syntax) searched in the golden +//! file name, the statement text and the failure detail; +//! * `family`: the function the failure names (`The feature function f`, `UNRESOLVED_ROUTINE`) +//! belongs to one of these Spark function groups (from the Spark function matrix). +//! +//! Rules only seed new entries: the baseline lists every statement with its category, and the +//! ratchet compares runs with that list, never with the rules. + +use std::collections::{BTreeMap, BTreeSet}; + +use regex_lite::Regex; +use serde_json::Value; + +use super::parse::Statement; + +/// One classification rule. +#[derive(Debug, Clone)] +pub struct Rule { + /// Category key the rule assigns. + pub category: String, + command: Option, + depends: Option, + file: Option, + query: Option, + detail: Option, + family: Option>, + /// The rule as written, for round trips. + source: Value, +} + +impl PartialEq for Rule { + fn eq(&self, other: &Self) -> bool { + self.source == other.source + } +} + +impl Eq for Rule {} + +impl Rule { + /// Parse one rule. + pub fn parse(v: &Value) -> Result { + let obj = v.as_object().ok_or("a rule is not an object")?; + for key in obj.keys() { + if ![ + "category", "command", "depends", "file", "query", "detail", "family", + ] + .contains(&key.as_str()) + { + return Err(format!("unknown rule key `{key}`")); + } + } + let category = obj + .get("category") + .and_then(Value::as_str) + .ok_or("a rule without `category`")? + .to_owned(); + let flag = |k: &str| -> Result, String> { + obj.get(k) + .map(|v| { + v.as_bool() + .ok_or(format!("rule `{category}`: `{k}` is not a boolean")) + }) + .transpose() + }; + let re = |k: &str| -> Result, String> { + obj.get(k) + .map(|v| { + let s = v + .as_str() + .ok_or(format!("rule `{category}`: `{k}` is not a string"))?; + Regex::new(s).map_err(|e| format!("rule `{category}`: `{k}`: {e}")) + }) + .transpose() + }; + let family = obj + .get("family") + .map(|v| { + v.as_array() + .ok_or(format!("rule `{category}`: `family` is not an array"))? + .iter() + .map(|f| { + f.as_str() + .map(str::to_owned) + .ok_or(format!("rule `{category}`: a family is not a string")) + }) + .collect::, _>>() + }) + .transpose()?; + let rule = Self { + command: flag("command")?, + depends: flag("depends")?, + file: re("file")?, + query: re("query")?, + detail: re("detail")?, + family, + source: v.clone(), + category, + }; + if rule.source.as_object().is_some_and(|o| o.len() == 1) { + return Err(format!("rule `{}` has no condition", rule.category)); + } + Ok(rule) + } + + /// The rule as JSON. + #[must_use] + pub const fn to_json(&self) -> &Value { + &self.source + } + + fn matches(&self, case: &Failure<'_>, families: &BTreeMap) -> bool { + let re = |r: &Option, s: &str| r.as_ref().is_none_or(|r| r.is_match(s)); + self.command.is_none_or(|c| c == case.command) + && self.depends.is_none_or(|d| d == case.depends) + && re(&self.file, case.file) + && re(&self.query, case.query) + && re(&self.detail, case.detail) + && self.family.as_ref().is_none_or(|fams| { + function_name(case.detail) + .and_then(|f| families.get(&f.to_ascii_lowercase())) + .is_some_and(|fam| fams.contains(fam)) + }) + } +} + +/// A failing statement, as the rules see it. +#[derive(Debug, Clone, Copy)] +pub struct Failure<'a> { + /// Golden file name. + pub file: &'a str, + /// Statement text. + pub query: &'a str, + /// Failure detail ([`super::run::Case::detail`]). + pub detail: &'a str, + /// The statement is a SQL command ([`is_command`]). + pub command: bool, + /// The statement mentions a name a command of the file creates ([`FileNames::mentioned_by`]). + pub depends: bool, +} + +/// The first rule of `rules` that matches `case`. +#[must_use] +pub fn classify<'r>( + rules: &'r [Rule], + case: &Failure<'_>, + families: &BTreeMap, +) -> Option<&'r str> { + rules + .iter() + .find(|r| r.matches(case, families)) + .map(|r| r.category.as_str()) +} + +/// Whether `query` is a SQL command rather than a query: it does not start with `SELECT`, +/// `WITH`, `VALUES`, `FROM`, `TABLE`, `EXPLAIN` or `(` (and is not empty). +#[must_use] +pub fn is_command(query: &str) -> bool { + let q = query.trim_start(); + if q.starts_with('(') { + return false; + } + let word: String = q + .chars() + .take_while(char::is_ascii_alphabetic) + .collect::() + .to_ascii_uppercase(); + !word.is_empty() + && !["SELECT", "WITH", "VALUES", "FROM", "TABLE", "EXPLAIN"].contains(&word.as_str()) +} + +/// The function a failure detail names: `The feature function f is not supported` or +/// `` UNRESOLVED_ROUTINE: Cannot resolve routine `f` ``. +#[must_use] +pub fn function_name(detail: &str) -> Option<&str> { + if let Some(rest) = detail.split("The feature function ").nth(1) { + return rest.split(" is not supported").next(); + } + let rest = detail.split("Cannot resolve routine `").nth(1)?; + rest.split('`').next() +} + +/// The names the commands of one golden file create (lower case, last name part). +#[derive(Debug, Clone, Default)] +pub struct FileNames(BTreeSet); + +impl FileNames { + /// Collect from the statements of a file. + #[must_use] + pub fn of(statements: &[Statement]) -> Self { + let mut names = BTreeSet::new(); + for s in statements { + // Words with their dots and backquotes, so a qualified name is one word. + let words: Vec<&str> = s + .query + .split(|c: char| !(c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | '`'))) + .filter(|w| !w.is_empty()) + .collect(); + let upper: Vec = words.iter().map(|w| w.to_ascii_uppercase()).collect(); + let at = |i: usize| upper.get(i).map_or("", String::as_str); + // `CREATE [OR REPLACE] [GLOBAL] [TEMP|TEMPORARY] VIEW|TABLE|FUNCTION|VARIABLE + // [IF NOT EXISTS] name`, `DECLARE [OR REPLACE] [VARIABLE] name`. + let mut i = match at(0) { + "CREATE" | "DECLARE" => 1, + _ => continue, + }; + let declare = at(0) == "DECLARE"; + while matches!(at(i), "OR" | "REPLACE" | "GLOBAL" | "TEMP" | "TEMPORARY") { + i += 1; + } + if matches!(at(i), "VIEW" | "TABLE" | "FUNCTION" | "VARIABLE") { + i += 1; + } else if !declare { + continue; + } + if at(i) == "IF" && at(i + 1) == "NOT" && at(i + 2) == "EXISTS" { + i += 3; + } + if let Some(last) = words + .get(i) + .and_then(|name| name.rsplit('.').next()) + .map(|n| n.trim_matches('`')) + .filter(|n| !n.is_empty()) + { + names.insert(last.to_ascii_lowercase()); + } + } + Self(names) + } + + /// Whether `query` mentions one of the names. + #[must_use] + pub fn mentioned_by(&self, query: &str) -> bool { + words(query) + .iter() + .any(|w| self.0.contains(&w.to_ascii_lowercase())) + } +} + +/// The identifier-like words of `s` (ASCII letters, digits, `_`; backquotes dropped), so a +/// qualified name gives its parts. +fn words(s: &str) -> Vec { + s.split(|c: char| !(c.is_ascii_alphanumeric() || c == '_')) + .filter(|w| !w.is_empty()) + .map(str::to_owned) + .collect() +} + +#[cfg(test)] +mod tests { + use serde_json::json; + + use super::*; + + fn stmt(q: &str) -> Statement { + Statement { + query: q.into(), + schema: String::new(), + expected: super::super::parse::Expected::Rows(String::new()), + } + } + + fn failure<'a>(query: &'a str, detail: &'a str) -> Failure<'a> { + Failure { + file: "group-by", + query, + detail, + command: is_command(query), + depends: false, + } + } + + #[test] + fn commands_and_created_names() { + for q in [ + "SELECT 1", + " with t as (select 1) select * from t", + "(SELECT 1)", + "VALUES 1", + "explain select 1", + "FROM t SELECT a", + "", + "TABLE t", + ] { + assert!(!is_command(q), "{q}"); + } + for q in [ + "CREATE TEMPORARY VIEW t AS SELECT 1", + "set a=b", + "DESC t", + "insert into t values 1", + ] { + assert!(is_command(q), "{q}"); + } + let names = FileNames::of(&[ + stmt("CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT 1"), + stmt("create table if not exists db.`t2` (a int)"), + stmt("DECLARE OR REPLACE VARIABLE v INT"), + stmt("declare w = 1"), + stmt("CREATE DATABASE nope"), + stmt("SELECT 1"), + ]); + assert!(names.mentioned_by("SELECT a FROM TESTDATA")); + assert!(names.mentioned_by("select * from db.t2")); + assert!(names.mentioned_by("SELECT v + w")); + assert!(!names.mentioned_by("SELECT * FROM nope2")); + assert!(!names.mentioned_by("SELECT * FROM db")); + } + + #[test] + fn function_names_from_details() { + assert_eq!( + function_name( + "error KRISHIV_UNSUPPORTED_FEATURE: The feature function to_timestamp is not supported by Krishiv yet." + ), + Some("to_timestamp") + ); + assert_eq!( + function_name("error UNRESOLVED_ROUTINE: Cannot resolve routine `udf` on search path"), + Some("udf") + ); + assert_eq!(function_name("rows differ"), None); + } + + #[test] + fn first_matching_rule_wins() -> Result<(), String> { + let rules = [ + Rule::parse(&json!({"category": "cmd", "command": true}))?, + Rule::parse(&json!({"category": "dep", "depends": true}))?, + Rule::parse(&json!({"category": "str", "family": ["string"]}))?, + Rule::parse( + &json!({"category": "win", "detail": "window functions", "file": "^group"}), + )?, + Rule::parse(&json!({"category": "cte", "query": "(?i)^with"}))?, + ]; + let families = BTreeMap::from([("upper".to_owned(), "string".to_owned())]); + let pick = |f: &Failure<'_>| classify(&rules, f, &families).map(str::to_owned); + assert_eq!( + pick(&failure("SET x=1", "parse failed")).as_deref(), + Some("cmd") + ); + let mut dep = failure("SELECT * FROM t", "error TABLE_OR_VIEW_NOT_FOUND"); + dep.depends = true; + assert_eq!(pick(&dep).as_deref(), Some("dep")); + assert_eq!( + pick(&failure( + "SELECT upper(a)", + "The feature function upper is not supported" + )) + .as_deref(), + Some("str") + ); + assert_eq!( + pick(&failure( + "SELECT lower(a)", + "The feature function lower is not supported" + )), + None + ); + assert_eq!( + pick(&failure( + "SELECT rank() OVER ()", + "The feature window functions is not" + )) + .as_deref(), + Some("win") + ); + assert_eq!( + pick(&failure("WITH t AS (SELECT 1) SELECT 2", "x")).as_deref(), + Some("cte") + ); + Ok(()) + } + + #[test] + fn bad_rules_are_rejected() { + for (rule, msg) in [ + (json!(1), "not an object"), + (json!({"command": true}), "without `category`"), + (json!({"category": "a"}), "no condition"), + ( + json!({"category": "a", "colour": "red"}), + "unknown rule key", + ), + (json!({"category": "a", "command": "yes"}), "not a boolean"), + (json!({"category": "a", "detail": "("}), "`detail`"), + (json!({"category": "a", "detail": 1}), "not a string"), + (json!({"category": "a", "family": "string"}), "not an array"), + (json!({"category": "a", "family": [1]}), "not a string"), + ] { + let err = Rule::parse(&rule).map(drop).unwrap_err(); + assert!(err.contains(msg), "{msg}: {err}"); + } + let r = Rule::parse(&json!({"category": "a", "query": "x"})); + assert_eq!( + r.map(|r| r.to_json().clone()), + Ok(json!({"category": "a", "query": "x"})) + ); + } +} diff --git a/crates/krishiv-testkit/src/golden/known_failures.rs b/crates/krishiv-testkit/src/golden/known_failures.rs new file mode 100644 index 000000000..9763d3395 --- /dev/null +++ b/crates/krishiv-testkit/src/golden/known_failures.rs @@ -0,0 +1,959 @@ +// SPDX-License-Identifier: Apache-2.0 +//! The frozen statement-level baseline of the session engine's golden run +//! (`tests/spark-golden/known-failures.json`): every statement that does not pass, each with a +//! category, and the ratchet that keeps the list from growing. +//! +//! ```json +//! {"format_version": 1, "spark_tag": "v4.2.0", "frozen_at": "2026-10-22", +//! "categories": { +//! "ddl": {"kind": "unsupported", "task": "P2-T075a", "summary": "DDL statements"}, +//! "float-text": {"kind": "divergence", "adr": "0023", "summary": "..."}, +//! "wrong-sum": {"kind": "bug", "owner": "U-agg", "summary": "..."}}, +//! "cases": {"group-by": {"ddl": [0, 1], "wrong-sum": [7]}}} +//! ``` +//! +//! A category is one of three kinds, each with a mandatory reference: an unsupported feature +//! names the plan task that adds it (`P2-T075a`), a known divergence names the ADR that records +//! it (ADR 0023, the Spark-divergence register), a bug names its owner in the internal status +//! list. Indices are statement positions in the golden file (0-based). The ratchet +//! ([`KnownFailures::check`]) fails on a statement that fails but is not listed (a regression) +//! and on a listed statement that passes (the list must shrink with it). + +use std::collections::{BTreeMap, BTreeSet}; +use std::path::{Path, PathBuf}; + +use serde_json::{Map, Value, json}; + +use super::GoldenSet; +use super::classify::{Failure, FileNames, Rule, classify, is_command}; +use super::parse::Statement; +use super::run::{RunResult, load_statements}; + +/// Format version this loader reads. +pub const KNOWN_FAILURES_FORMAT_VERSION: u64 = 1; + +/// The ADR a known divergence must cite. +pub const DIVERGENCE_ADR: &str = "0023"; + +/// What a category is, with its mandatory reference. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum CategoryKind { + /// A feature Krishiv does not have yet; the plan task that adds it. + Unsupported { + /// Plan task ID, `P-T[letter]`. + task: String, + }, + /// A deliberate difference from Spark recorded in an ADR. + Divergence { + /// ADR number ([`DIVERGENCE_ADR`]). + adr: String, + }, + /// A defect; who owns the fix. + Bug { + /// Owner as named in the internal status list. + owner: String, + }, +} + +/// A failure category. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Category { + /// Kind and reference. + pub kind: CategoryKind, + /// One line on what fails and why. + pub summary: String, +} + +/// A problem with the known-failures file. +#[derive(Debug, thiserror::Error)] +pub enum KnownFailuresError { + /// Reading the file failed. + #[error("reading {path}: {source}")] + Io { + /// File path. + path: PathBuf, + /// Underlying error. + source: std::io::Error, + }, + /// Not valid JSON, or the wrong shape. + #[error("invalid known-failures file: {0}")] + Invalid(String), +} + +/// The frozen baseline. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct KnownFailures { + /// Spark tag the baseline was taken on. + pub spark_tag: String, + /// Date of the freeze (`YYYY-MM-DD`). + pub frozen_at: String, + /// Categories by key. + pub categories: BTreeMap, + /// Classification rules for new failures, in order ([`super::classify`]). + pub rules: Vec, + /// Per golden file: statement index → category key. + pub cases: BTreeMap>, +} + +/// What [`KnownFailures::update`] changed. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct Update { + /// Statements added, with their category. + pub added: Vec<(Drift, String)>, + /// Listed statements removed because they pass (or no longer exist). + pub removed: Vec, + /// Failing statements no rule classifies; nothing is written while there are any. + pub unclassified: Vec, +} + +/// A statement whose outcome disagrees with the baseline. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Drift { + /// Golden file. + pub file: String, + /// Statement index. + pub index: u32, + /// Why it failed (empty for a statement that now passes). + pub detail: String, +} + +/// The ratchet's verdict. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct Ratchet { + /// Statements that fail but are not listed: regressions (or new statements). + pub newly_failing: Vec, + /// Listed statements that pass: remove them from the list. + pub newly_passing: Vec, + /// Listed files the run did not run (renamed, removed or excluded). + pub missing_files: Vec, +} + +impl Ratchet { + /// Whether the run matches the baseline exactly. + #[must_use] + pub fn is_clean(&self) -> bool { + self.newly_failing.is_empty() + && self.newly_passing.is_empty() + && self.missing_files.is_empty() + } + + /// A readable account of every disagreement. + #[must_use] + pub fn describe(&self) -> String { + let mut s = String::new(); + if !self.newly_failing.is_empty() { + s.push_str(&format!( + "{} statement(s) fail that the baseline does not list (fix them, or list them \ + with a category in tests/spark-golden/known-failures.json):\n", + self.newly_failing.len() + )); + for d in &self.newly_failing { + s.push_str(&format!(" {}#{}: {}\n", d.file, d.index, d.detail)); + } + } + if !self.newly_passing.is_empty() { + s.push_str(&format!( + "{} listed statement(s) now pass; remove them from \ + tests/spark-golden/known-failures.json:\n", + self.newly_passing.len() + )); + for d in &self.newly_passing { + s.push_str(&format!(" {}#{}\n", d.file, d.index)); + } + } + for f in &self.missing_files { + s.push_str(&format!("listed file `{f}` did not run\n")); + } + s + } +} + +fn is_task_id(s: &str) -> bool { + // `P-T[a-z]` + let Some(rest) = s.strip_prefix('P') else { + return false; + }; + let Some((phase, task)) = rest.split_once("-T") else { + return false; + }; + let digits = task.trim_end_matches(|c: char| c.is_ascii_lowercase()); + !phase.is_empty() + && phase.chars().all(|c| c.is_ascii_digit()) + && !digits.is_empty() + && digits.chars().all(|c| c.is_ascii_digit()) + && task.len() - digits.len() <= 1 +} + +impl KnownFailures { + /// Default path in the repo. + #[must_use] + pub fn default_path() -> PathBuf { + crate::tests_dir() + .join("spark-golden") + .join("known-failures.json") + } + + /// Load from `path`. + pub fn load(path: &Path) -> Result { + let text = std::fs::read_to_string(path).map_err(|source| KnownFailuresError::Io { + path: path.to_path_buf(), + source, + })?; + Self::parse(&text) + } + + /// Parse JSON text, validating every category and case. + pub fn parse(text: &str) -> Result { + let bad = |m: String| KnownFailuresError::Invalid(m); + let root: Value = serde_json::from_str(text).map_err(|e| bad(e.to_string()))?; + if root.get("format_version").and_then(Value::as_u64) != Some(KNOWN_FAILURES_FORMAT_VERSION) + { + return Err(bad("unsupported or missing `format_version`".into())); + } + let text_field = |v: &Value, k: &str| v.get(k).and_then(Value::as_str).map(str::to_owned); + let spark_tag = + text_field(&root, "spark_tag").ok_or_else(|| bad("missing `spark_tag`".into()))?; + let frozen_at = + text_field(&root, "frozen_at").ok_or_else(|| bad("missing `frozen_at`".into()))?; + let mut categories = BTreeMap::new(); + for (key, c) in root + .get("categories") + .and_then(Value::as_object) + .ok_or_else(|| bad("missing `categories` object".into()))? + { + let summary = text_field(c, "summary") + .filter(|s| !s.trim().is_empty()) + .ok_or_else(|| bad(format!("category `{key}` without a `summary`")))?; + let reference = |k: &str| { + text_field(c, k) + .filter(|s| !s.trim().is_empty()) + .ok_or_else(|| bad(format!("category `{key}` without `{k}`"))) + }; + let kind = match c.get("kind").and_then(Value::as_str) { + Some("unsupported") => { + let task = reference("task")?; + if !is_task_id(&task) { + return Err(bad(format!("category `{key}`: `{task}` is not a task ID"))); + } + CategoryKind::Unsupported { task } + } + Some("divergence") => { + let adr = reference("adr")?; + if adr != DIVERGENCE_ADR { + return Err(bad(format!( + "category `{key}`: a divergence cites ADR {DIVERGENCE_ADR}, not `{adr}`" + ))); + } + CategoryKind::Divergence { adr } + } + Some("bug") => CategoryKind::Bug { + owner: reference("owner")?, + }, + other => { + return Err(bad(format!("category `{key}`: unknown kind {other:?}"))); + } + }; + categories.insert(key.clone(), Category { kind, summary }); + } + let mut rules = Vec::new(); + for r in root + .get("rules") + .and_then(Value::as_array) + .ok_or_else(|| bad("missing `rules` array".into()))? + { + let rule = Rule::parse(r).map_err(bad)?; + if !categories.contains_key(&rule.category) { + return Err(bad(format!( + "a rule names the unknown category `{}`", + rule.category + ))); + } + rules.push(rule); + } + let mut cases = BTreeMap::new(); + for (file, by_category) in root + .get("cases") + .and_then(Value::as_object) + .ok_or_else(|| bad("missing `cases` object".into()))? + { + let mut indices = BTreeMap::new(); + for (key, list) in by_category + .as_object() + .ok_or_else(|| bad(format!("`{file}`: expected an object of categories")))? + { + if !categories.contains_key(key) { + return Err(bad(format!("`{file}`: unknown category `{key}`"))); + } + for i in list + .as_array() + .ok_or_else(|| bad(format!("`{file}`/`{key}`: expected an array")))? + { + let i = i + .as_u64() + .and_then(|i| u32::try_from(i).ok()) + .ok_or_else(|| bad(format!("`{file}`/`{key}`: bad index {i}")))?; + if indices.insert(i, key.clone()).is_some() { + return Err(bad(format!("`{file}`#{i} is listed twice"))); + } + } + } + if indices.is_empty() { + return Err(bad(format!("`{file}` lists no statements"))); + } + cases.insert(file.clone(), indices); + } + Ok(Self { + spark_tag, + frozen_at, + categories, + rules, + cases, + }) + } + + /// The JSON form (stable key order; one file per line in the pretty form). + #[must_use] + pub fn to_json(&self) -> Value { + let categories: Map = self + .categories + .iter() + .map(|(k, c)| { + let v = match &c.kind { + CategoryKind::Unsupported { task } => { + json!({"kind": "unsupported", "task": task, "summary": c.summary}) + } + CategoryKind::Divergence { adr } => { + json!({"kind": "divergence", "adr": adr, "summary": c.summary}) + } + CategoryKind::Bug { owner } => { + json!({"kind": "bug", "owner": owner, "summary": c.summary}) + } + }; + (k.clone(), v) + }) + .collect(); + let cases: Map = self + .cases + .iter() + .map(|(file, indices)| { + let mut by: BTreeMap<&str, Vec> = BTreeMap::new(); + for (i, k) in indices { + by.entry(k).or_default().push(*i); + } + (file.clone(), json!(by)) + }) + .collect(); + json!({ + "format_version": KNOWN_FAILURES_FORMAT_VERSION, + "spark_tag": self.spark_tag, + "frozen_at": self.frozen_at, + "categories": categories, + "rules": self.rules.iter().map(Rule::to_json).collect::>(), + "cases": cases, + }) + } + + /// The file text: pretty JSON, with each golden file's cases on one line so that a change + /// to one file is a one-line diff. + #[must_use] + pub fn to_text(&self) -> String { + let doc = self.to_json(); + let mut head = doc.clone(); + if let Some(o) = head.as_object_mut() { + o.remove("cases"); + } + let head = serde_json::to_string_pretty(&head).unwrap_or_default(); + let head = head.trim_end().trim_end_matches('}').trim_end(); + let mut out = format!("{head},\n \"cases\": {{\n"); + let files = doc.get("cases").and_then(Value::as_object); + let n = files.map_or(0, Map::len); + for (i, (file, by)) in files.into_iter().flatten().enumerate() { + let sep = if i + 1 == n { "" } else { "," }; + out.push_str(&format!(" {}: {by}{sep}\n", Value::String(file.clone()))); + } + out.push_str(" }\n}\n"); + out + } + + /// [`Self::update`] for a run over `set`: the statements come from the set's files and the + /// function groups from the Spark function matrix ([`crate::fn_matrix`]). + pub fn update_with_set(&mut self, run: &RunResult, set: &GoldenSet) -> Result { + let mut statements = BTreeMap::new(); + for pair in &set.pairs { + statements.insert( + pair.name.clone(), + load_statements(pair).map_err(|e| e.to_string())?, + ); + } + let families: BTreeMap = crate::fn_matrix::FnMatrix::load_default() + .map_err(|e| e.to_string())? + .functions + .into_iter() + .map(|f| (f.name.to_ascii_lowercase(), f.family)) + .collect(); + Ok(self.update(run, &statements, &families)) + } + + /// The ratchet over the file at `path`: `Ok` with a one-line summary when `run` fails + /// exactly the listed statements and every category is used, else `Err` with every + /// disagreement. + pub fn check_file(path: &Path, run: &RunResult) -> Result { + let known = Self::load(path).map_err(|e| e.to_string())?; + let r = known.check(run); + if !r.is_clean() { + return Err(r.describe()); + } + let unused = known.unused_categories(); + if !unused.is_empty() { + return Err(format!( + "categories without cases (remove them): {unused:?}" + )); + } + Ok(format!( + "ratchet: the run matches the {} known failures of {}", + known.listed(), + path.display() + )) + } + + /// [`Self::update_with_set`] on the file at `path`, rewriting it; `Err` (and the file + /// untouched) when a failure matches no rule. + pub fn update_file(path: &Path, run: &RunResult, set: &GoldenSet) -> Result { + let mut known = Self::load(path).map_err(|e| e.to_string())?; + let up = known.update_with_set(run, set)?; + if !up.unclassified.is_empty() { + let mut msg = format!( + "{} failure(s) match no rule; add a rule or category to {} (nothing written):\n", + up.unclassified.len(), + path.display() + ); + for d in &up.unclassified { + msg.push_str(&format!(" {}#{}: {}\n", d.file, d.index, d.detail)); + } + return Err(msg); + } + std::fs::write(path, known.to_text()).map_err(|e| format!("{}: {e}", path.display()))?; + Ok(format!( + "ratchet: {} added, {} removed, {} listed in {}", + up.added.len(), + up.removed.len(), + known.listed(), + path.display() + )) + } + + /// Bring the baseline in line with `run`: drop the listed statements that pass (or are + /// gone), keep the categories of the ones still failing, and classify new failures with + /// [`Self::rules`]. `statements` holds each run file's statements (for the rules); + /// `families` maps function names to their Spark function group. Categories left without + /// cases are dropped with their rules. Nothing changes while a failure is unclassified. + pub fn update( + &mut self, + run: &RunResult, + statements: &BTreeMap>, + families: &BTreeMap, + ) -> Update { + let mut up = Update::default(); + let mut next: BTreeMap> = BTreeMap::new(); + let empty = Vec::new(); + for f in &run.files { + let stmts = statements.get(&f.name).unwrap_or(&empty); + let names = FileNames::of(stmts); + let listed = self.cases.get(&f.name); + let mut kept = BTreeMap::new(); + for c in &f.cases { + let drift = || Drift { + file: f.name.clone(), + index: c.index, + detail: c.detail.clone(), + }; + let old = listed.and_then(|l| l.get(&c.index)); + if c.passed() { + if old.is_some() { + up.removed.push(drift()); + } + continue; + } + if let Some(k) = old { + kept.insert(c.index, k.clone()); + continue; + } + let query = usize::try_from(c.index) + .ok() + .and_then(|i| stmts.get(i)) + .map_or("", |s| s.query.as_str()); + let failure = Failure { + file: &f.name, + query, + detail: &c.detail, + command: is_command(query), + depends: names.mentioned_by(query), + }; + match classify(&self.rules, &failure, families) { + Some(k) => { + up.added.push((drift(), k.to_owned())); + kept.insert(c.index, k.to_owned()); + } + None => up.unclassified.push(drift()), + } + } + if let Some(l) = listed { + let present: BTreeSet = f.cases.iter().map(|c| c.index).collect(); + for i in l.keys().filter(|i| !present.contains(i)) { + up.removed.push(Drift { + file: f.name.clone(), + index: *i, + detail: String::new(), + }); + } + } + if !kept.is_empty() { + next.insert(f.name.clone(), kept); + } + } + if !up.unclassified.is_empty() { + return up; + } + let used: BTreeSet = next.values().flat_map(BTreeMap::values).cloned().collect(); + self.categories.retain(|k, _| used.contains(k)); + self.rules.retain(|r| used.contains(&r.category)); + self.cases = next; + up + } + + /// Categories no listed statement uses (stale after fixes; [`Self::update`] drops them). + #[must_use] + pub fn unused_categories(&self) -> Vec<&str> { + let used: BTreeSet<&str> = self + .cases + .values() + .flat_map(BTreeMap::values) + .map(String::as_str) + .collect(); + self.categories + .keys() + .map(String::as_str) + .filter(|k| !used.contains(k)) + .collect() + } + + /// Number of listed statements. + #[must_use] + pub fn listed(&self) -> usize { + self.cases.values().map(BTreeMap::len).sum() + } + + /// Listed statements per category key. + #[must_use] + pub fn counts(&self) -> BTreeMap<&str, usize> { + let mut out = BTreeMap::new(); + for k in self.cases.values().flat_map(BTreeMap::values) { + *out.entry(k.as_str()).or_default() += 1; + } + out + } + + /// Compare `run` with the baseline. + #[must_use] + pub fn check(&self, run: &RunResult) -> Ratchet { + let mut r = Ratchet::default(); + let empty = BTreeMap::new(); + let mut ran = BTreeSet::new(); + for f in &run.files { + ran.insert(f.name.as_str()); + let listed = self.cases.get(&f.name).unwrap_or(&empty); + for c in &f.cases { + match (c.passed(), listed.contains_key(&c.index)) { + (false, false) => r.newly_failing.push(Drift { + file: f.name.clone(), + index: c.index, + detail: c.detail.clone(), + }), + (true, true) => r.newly_passing.push(Drift { + file: f.name.clone(), + index: c.index, + detail: String::new(), + }), + _ => {} + } + } + // A listed index the file does not have (the file shrank) counts as passing. + let present: BTreeSet = f.cases.iter().map(|c| c.index).collect(); + for i in listed.keys().filter(|i| !present.contains(i)) { + r.newly_passing.push(Drift { + file: f.name.clone(), + index: *i, + detail: String::new(), + }); + } + } + r.missing_files = self + .cases + .keys() + .filter(|f| !ran.contains(f.as_str())) + .cloned() + .collect(); + r + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::golden::run::{Case, FileResult}; + + type R = Result<(), Box>; + + const DOC: &str = r#"{"format_version":1,"spark_tag":"v4.2.0","frozen_at":"2026-10-22", + "categories":{ + "ddl":{"kind":"unsupported","task":"P2-T075a","summary":"DDL"}, + "text":{"kind":"divergence","adr":"0023","summary":"float text"}, + "sum":{"kind":"bug","owner":"U-agg","summary":"wrong sum"}}, + "rules":[{"category":"ddl","command":true},{"category":"sum","detail":"rows differ"}], + "cases":{"a":{"ddl":[0,1],"sum":[3]},"b":{"text":[2]}}}"#; + + fn case(index: u32, passed: bool) -> Case { + Case { + index, + result: Some(passed), + detail: if passed { + String::new() + } else { + "rows differ".into() + }, + ..Case::default() + } + } + + fn file(name: &str, cases: Vec) -> FileResult { + FileResult { + name: name.into(), + cases, + ..FileResult::default() + } + } + + #[test] + fn parses_and_round_trips() -> R { + let k = KnownFailures::parse(DOC)?; + assert_eq!(k.listed(), 4); + assert_eq!(k.counts().get("ddl"), Some(&2)); + assert!(k.unused_categories().is_empty()); + let k2 = KnownFailures::parse(&DOC.replace(r#","b":{"text":[2]}"#, ""))?; + assert_eq!(k2.unused_categories(), ["text"]); + assert_eq!( + k.categories["sum"].kind, + CategoryKind::Bug { + owner: "U-agg".into() + } + ); + let again = KnownFailures::parse(&k.to_json().to_string())?; + assert_eq!(again, k); + Ok(()) + } + + #[test] + fn rejects_bad_references_and_shapes() { + let cases = [ + (r#""task":"T075a""#, "is not a task ID"), + (r#""task":"P2-T075ab""#, "is not a task ID"), + (r#""task":"P2T075""#, "is not a task ID"), + (r#""task":"P-T075""#, "is not a task ID"), + ]; + for (task, msg) in cases { + let doc = DOC.replace(r#""task":"P2-T075a""#, task); + let err = KnownFailures::parse(&doc) + .map(drop) + .unwrap_err() + .to_string(); + assert!(err.contains(msg), "{err}"); + } + let checks = [ + ( + DOC.replace(r#""adr":"0023""#, r#""adr":"0012""#), + "cites ADR 0023", + ), + (DOC.replace(r#","owner":"U-agg""#, ""), "without `owner`"), + ( + DOC.replace(r#""kind":"bug""#, r#""kind":"later""#), + "unknown kind", + ), + ( + DOC.replace(r#""summary":"wrong sum""#, r#""summary":" ""#), + "without a `summary`", + ), + ( + DOC.replace(r#""b":{"text":[2]}"#, r#""b":{"nope":[2]}"#), + "unknown category", + ), + (DOC.replace(r#""sum":[3]"#, r#""sum":[1]"#), "listed twice"), + (DOC.replace(r#""sum":[3]"#, r#""sum":[-1]"#), "bad index"), + ( + DOC.replace(r#""format_version":1"#, r#""format_version":2"#), + "format_version", + ), + ( + DOC.replace(r#""b":{"text":[2]}"#, r#""b":{}"#), + "lists no statements", + ), + ( + DOC.replace( + r#"{"category":"ddl","command":true}"#, + r#"{"category":"zzz","command":true}"#, + ), + "unknown category `zzz`", + ), + ( + DOC.replace( + r#"{"category":"ddl","command":true}"#, + r#"{"category":"ddl"}"#, + ), + "no condition", + ), + (DOC.replace(r#""rules":"#, r#""rulez":"#), "missing `rules`"), + ]; + for (doc, msg) in checks { + let err = KnownFailures::parse(&doc) + .map(drop) + .unwrap_err() + .to_string(); + assert!(err.contains(msg), "{msg}: {err}"); + } + } + + #[test] + fn ratchet_flags_new_failures_and_new_passes() -> R { + let k = KnownFailures::parse(DOC)?; + let run = RunResult { + files: vec![ + file( + "a", + vec![ + case(0, false), + case(1, true), + case(2, false), + case(3, false), + ], + ), + file("b", vec![case(2, false)]), + ], + ..RunResult::default() + }; + let r = k.check(&run); + assert_eq!( + r.newly_failing, + [Drift { + file: "a".into(), + index: 2, + detail: "rows differ".into() + }] + ); + assert_eq!(r.newly_passing.len(), 1); + assert_eq!( + (r.newly_passing[0].file.as_str(), r.newly_passing[0].index), + ("a", 1) + ); + assert!(r.missing_files.is_empty()); + assert!(!r.is_clean()); + let text = r.describe(); + assert!( + text.contains("a#2: rows differ") && text.contains("remove them"), + "{text}" + ); + Ok(()) + } + + #[test] + fn ratchet_is_clean_on_the_baseline_and_flags_missing_files() -> R { + let k = KnownFailures::parse(DOC)?; + let mut run = RunResult { + files: vec![ + file( + "a", + vec![ + case(0, false), + case(1, false), + case(2, true), + case(3, false), + ], + ), + file("b", vec![case(2, false)]), + ], + ..RunResult::default() + }; + assert!(k.check(&run).is_clean()); + run.files.truncate(1); + let r = k.check(&run); + assert_eq!(r.missing_files, ["b"]); + assert!(r.describe().contains("listed file `b` did not run")); + // A listed statement the file no longer has must be removed too. + run.files[0].cases.truncate(3); + assert_eq!(k.check(&run).newly_passing.len(), 1); + Ok(()) + } + + fn stmt(q: &str) -> Statement { + Statement { + query: q.into(), + schema: String::new(), + expected: crate::golden::parse::Expected::Rows(String::new()), + } + } + + #[test] + fn update_keeps_categories_drops_passes_and_classifies_new_failures() -> R { + let mut k = KnownFailures::parse(DOC)?; + let run = RunResult { + files: vec![ + // a#0 still fails (kept as ddl), a#1 passes (removed), a#2 is new (a command: ddl), + // a#3 is gone (removed); b is not run (dropped with `text`). + file("a", vec![case(0, false), case(1, true), case(2, false)]), + // c#0 is new and matches the `sum` rule by its detail. + file("c", vec![case(0, false)]), + ], + ..RunResult::default() + }; + let statements = BTreeMap::from([ + ( + "a".to_owned(), + vec![ + stmt("CREATE VIEW v AS SELECT 1"), + stmt("SELECT 1"), + stmt("SET x=1"), + ], + ), + ("c".to_owned(), vec![stmt("SELECT 2")]), + ]); + let up = k.update(&run, &statements, &BTreeMap::new()); + assert!(up.unclassified.is_empty()); + assert_eq!( + up.added + .iter() + .map(|(d, c)| (d.file.as_str(), d.index, c.as_str())) + .collect::>(), + [("a", 2, "ddl"), ("c", 0, "sum")] + ); + assert_eq!( + up.removed + .iter() + .map(|d| (d.file.as_str(), d.index)) + .collect::>(), + [("a", 1), ("a", 3)] + ); + assert_eq!(k.listed(), 3); + assert!(!k.categories.contains_key("text")); + assert!(k.check(&run).is_clean()); + // The written text parses back to the same baseline, one line per file. + let text = k.to_text(); + assert_eq!(KnownFailures::parse(&text)?, k); + assert!(text.contains("\n \"a\": {\"ddl\":[0,2]},\n"), "{text}"); + Ok(()) + } + + #[test] + fn update_changes_nothing_while_a_failure_is_unclassified() -> R { + let mut k = KnownFailures::parse(DOC)?; + let before = k.clone(); + let mut run = RunResult::default(); + let mut odd = case(5, false); + odd.detail = "error X: odd".into(); + run.files = vec![file("a", vec![case(0, false), odd])]; + let statements = BTreeMap::from([("a".to_owned(), vec![stmt("SELECT 1"); 6])]); + let up = k.update(&run, &statements, &BTreeMap::new()); + assert_eq!(up.unclassified.len(), 1); + assert_eq!(up.unclassified[0].index, 5); + assert_eq!(k, before); + Ok(()) + } + + #[test] + fn update_with_set_reads_statements_and_function_groups() -> R { + let dir = tempfile::tempdir()?; + std::fs::create_dir_all(dir.path().join("inputs"))?; + std::fs::create_dir_all(dir.path().join("results"))?; + std::fs::write(dir.path().join("inputs/z.sql"), "select upper('x');\n")?; + std::fs::write( + dir.path().join("results/z.sql.out"), + "-- !query\nselect upper('x')\n-- !query schema\nstruct\n-- !query output\nX\n", + )?; + let set = GoldenSet::scan(dir.path())?; + let mut k = KnownFailures::parse(&DOC.replace( + r#"{"category":"sum","detail":"rows differ"}"#, + r#"{"category":"sum","family":["string"]}"#, + ))?; + let mut run = RunResult::default(); + let mut c = case(0, false); + c.detail = + "error KRISHIV_UNSUPPORTED_FEATURE: The feature function upper is not supported".into(); + run.files = vec![file("z", vec![c])]; + let up = k.update_with_set(&run, &set)?; + assert_eq!(up.added.len(), 1, "{up:?}"); + assert_eq!(up.added[0].1, "sum"); + Ok(()) + } + + #[test] + fn files_are_checked_and_updated_in_place() -> R { + let dir = tempfile::tempdir()?; + let path = dir.path().join("known.json"); + let missing = KnownFailures::check_file(&path, &RunResult::default()).unwrap_err(); + assert!(missing.contains("reading"), "{missing}"); + std::fs::write(&path, DOC)?; + let clean = RunResult { + files: vec![ + file("a", vec![case(0, false), case(1, false), case(3, false)]), + file("b", vec![case(2, false)]), + ], + ..RunResult::default() + }; + let ok = KnownFailures::check_file(&path, &clean)?; + assert!(ok.contains("matches the 4 known failures"), "{ok}"); + let drift = RunResult { + files: vec![file("b", vec![case(2, false)])], + ..RunResult::default() + }; + let err = KnownFailures::check_file(&path, &drift).unwrap_err(); + assert!(err.contains("listed file `a` did not run"), "{err}"); + std::fs::write(&path, DOC.replace(r#","b":{"text":[2]}"#, ""))?; + let only_a = RunResult { + files: vec![file( + "a", + vec![case(0, false), case(1, false), case(3, false)], + )], + ..RunResult::default() + }; + let err = KnownFailures::check_file(&path, &only_a).unwrap_err(); + assert!(err.contains("categories without cases"), "{err}"); + + // Update: `a#5` matches no rule, so nothing is written; then it passes and `a#1` + // passes too, and the file shrinks. + let set = GoldenSet::default(); + std::fs::write(&path, DOC)?; + let mut odd = case(5, false); + odd.detail = "error X".into(); + let with_odd = RunResult { + files: vec![ + file( + "a", + vec![case(0, false), case(1, false), case(3, false), odd], + ), + file("b", vec![case(2, false)]), + ], + ..RunResult::default() + }; + let err = KnownFailures::update_file(&path, &with_odd, &set).unwrap_err(); + assert!(err.contains("a#5: error X"), "{err}"); + assert_eq!(std::fs::read_to_string(&path)?, DOC); + let fewer = RunResult { + files: vec![ + file("a", vec![case(0, false), case(1, true), case(3, false)]), + file("b", vec![case(2, false)]), + ], + ..RunResult::default() + }; + let msg = KnownFailures::update_file(&path, &fewer, &set)?; + assert!(msg.contains("0 added, 1 removed, 3 listed"), "{msg}"); + assert!(KnownFailures::check_file(&path, &fewer).is_ok()); + Ok(()) + } +} diff --git a/crates/krishiv-testkit/src/golden/mod.rs b/crates/krishiv-testkit/src/golden/mod.rs index 64e1447e7..1552c7d3a 100644 --- a/crates/krishiv-testkit/src/golden/mod.rs +++ b/crates/krishiv-testkit/src/golden/mod.rs @@ -9,12 +9,15 @@ //! three separate numbers ([`report`]); [`manifest`] holds the exclusion manifest. pub mod cell; +pub mod classify; pub mod fixtures; +pub mod known_failures; pub mod manifest; pub mod normalise; pub mod parse; pub mod report; pub mod run; +pub mod session_engine; pub mod setup; pub mod sorted; pub mod sql_parse; diff --git a/crates/krishiv-testkit/src/golden/report.rs b/crates/krishiv-testkit/src/golden/report.rs index 44fea26e9..684532791 100644 --- a/crates/krishiv-testkit/src/golden/report.rs +++ b/crates/krishiv-testkit/src/golden/report.rs @@ -92,6 +92,35 @@ pub fn to_json(run: &RunResult, tag: &str, manifest: &ExclusionManifest) -> Valu }) } +/// Every counted statement that did not pass, per file: index, the numbers it failed and why. +#[must_use] +pub fn cases_json(run: &RunResult) -> Value { + let mut files = serde_json::Map::new(); + for f in &run.files { + let failed: Vec = f + .cases + .iter() + .filter(|c| !c.passed()) + .map(|c| { + let failed: Vec<&str> = [ + ("parse", c.parse), + ("negative", c.negative), + ("result", c.result), + ] + .into_iter() + .filter(|(_, v)| *v == Some(false)) + .map(|(k, _)| k) + .collect(); + json!({"index": c.index, "failed": failed, "detail": c.detail}) + }) + .collect(); + if !failed.is_empty() { + files.insert(f.name.clone(), Value::Array(failed)); + } + } + Value::Object(files) +} + /// The report as pretty-printed JSON with a trailing newline. pub fn to_json_string(report: &Value) -> Result { let mut s = serde_json::to_string_pretty(report)?; @@ -152,6 +181,7 @@ mod tests { }, unclassified_errors: 1, runs: 2, + cases: Vec::new(), }], excluded: vec![SkippedFile { name: "udf/x".into(), @@ -169,4 +199,41 @@ mod tests { insta::assert_snapshot!(to_json_string(&to_json(&run, "v4.2.0", &manifest))?); Ok(()) } + + #[test] + fn cases_json_lists_only_the_failures() { + use crate::golden::run::Case; + let run = RunResult { + files: vec![ + FileResult { + name: "a".into(), + cases: vec![ + Case { + index: 0, + parse: Some(true), + result: Some(true), + ..Case::default() + }, + Case { + index: 3, + parse: Some(false), + negative: Some(false), + detail: "parse failed; no error".into(), + ..Case::default() + }, + ], + ..FileResult::default() + }, + FileResult { + name: "b".into(), + ..FileResult::default() + }, + ], + ..RunResult::default() + }; + assert_eq!( + cases_json(&run), + serde_json::json!({"a": [{"index": 3, "failed": ["parse", "negative"], "detail": "parse failed; no error"}]}) + ); + } } diff --git a/crates/krishiv-testkit/src/golden/run.rs b/crates/krishiv-testkit/src/golden/run.rs index 458d86bee..630dec670 100644 --- a/crates/krishiv-testkit/src/golden/run.rs +++ b/crates/krishiv-testkit/src/golden/run.rs @@ -140,6 +140,34 @@ pub struct FileResult { pub result: Tally, /// Spark errors without an error class (outside the negative denominator). pub unclassified_errors: u64, + /// Per-statement outcomes, in file order (the counted statements only). + pub cases: Vec, +} + +/// What one statement of a file scored, merged over the file's runs. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct Case { + /// Position of the statement in the file (0-based, over all statements). + pub index: u32, + /// Number 1, when the statement counts for it. + pub parse: Option, + /// Number 2, when the statement counts for it. + pub negative: Option, + /// Number 3, when the statement counts for it. + pub result: Option, + /// Why the statement failed in the first run it failed in (empty when it passed). + pub detail: String, +} + +impl Case { + /// Whether every number the statement counts for passed. + #[must_use] + pub fn passed(&self) -> bool { + [self.parse, self.negative, self.result] + .into_iter() + .flatten() + .all(|p| p) + } } /// A skipped file and what it would have counted for. @@ -296,12 +324,13 @@ fn note_unregistered(statements: &[Statement], out: &mut BTreeSet) { } /// What one statement scored in one run; `None` means it does not count for that number. -#[derive(Debug, Clone, Copy, Default)] +#[derive(Debug, Clone, Default)] struct Outcome { parse: Option, negative: Option, result: Option, unclassified: bool, + detail: String, } impl Outcome { @@ -316,6 +345,11 @@ impl Outcome { negative: both(self.negative, other.negative), result: both(self.result, other.result), unclassified: self.unclassified, + detail: if self.detail.is_empty() { + other.detail + } else { + self.detail + }, } } } @@ -362,8 +396,8 @@ pub fn run_file_with( runs: sessions.len() as u64, ..FileResult::default() }; - let merged = merged.unwrap_or_default().into_iter().zip(kept); - for o in merged.filter_map(|(o, k)| k.then_some(o)) { + let merged = merged.unwrap_or_default().into_iter().zip(kept).enumerate(); + for (index, o) in merged.filter_map(|(i, (o, k))| k.then_some((i, o))) { for (tally, v) in [ (&mut file.parse, o.parse), (&mut file.negative, o.negative), @@ -374,12 +408,23 @@ pub fn run_file_with( } } file.unclassified_errors += u64::from(o.unclassified); + let mut case = Case { + index: u32::try_from(index).unwrap_or(u32::MAX), + parse: o.parse, + negative: o.negative, + result: o.result, + detail: String::new(), + }; + if !case.passed() { + case.detail = o.detail; + } + file.cases.push(case); } file } fn failed(s: &Statement) -> Outcome { - outcome(s, false, None, None) + outcome(s, false, None) } fn run_session(engine: &mut dyn Engine, statements: &[Statement]) -> Vec { @@ -390,38 +435,85 @@ fn run_session(engine: &mut dyn Engine, statements: &[Statement]) -> Vec String { + let message: String = e + .message + .lines() + .next() + .unwrap_or_default() + .chars() + .take(160) + .collect(); + format!("error {}: {message}", e.class.as_deref().unwrap_or("-")) +} + +/// What `s` scored: `executed` is the engine's answer with the run's masker, `None` when the +/// statement could not run (the session could not be set up). fn outcome( s: &Statement, parsed: bool, - executed: Option>, - masker: Option<&Masker>, + executed: Option<(Result, &Masker)>, ) -> Outcome { + let parse_detail = || { + if parsed { + String::new() + } else { + "parse failed; ".to_owned() + } + }; match &s.expected { - Expected::Rows(output) => Outcome { - parse: Some(parsed), - result: Some( - executed - .and_then(Result::ok) - .zip(masker) - .is_some_and(|(got, m)| result_matches(s, output, &got, m)), - ), - ..Outcome::default() - }, - Expected::Error(e) => Outcome { - parse: (!e.is_parse_error()).then_some(parsed), - negative: e.error_class.as_deref().map(|class| { - executed - .and_then(Result::err) - .is_some_and(|got| error_matches(e, class, &got)) - }), - unclassified: e.error_class.is_none(), - ..Outcome::default() - }, + Expected::Rows(output) => { + let (passed, why) = match executed { + Some((Ok(got), m)) => match result_mismatch(s, output, &got, m) { + None => (true, String::new()), + Some(why) => (false, why), + }, + Some((Err(e), _)) => (false, error_detail(&e)), + None => (false, "not executed".to_owned()), + }; + Outcome { + parse: Some(parsed), + result: Some(passed), + detail: if passed && parsed { + String::new() + } else { + format!("{}{why}", parse_detail()) + }, + ..Outcome::default() + } + } + Expected::Error(e) => { + let counts_parse = !e.is_parse_error(); + let (negative, why) = match e.error_class.as_deref() { + None => (None, String::new()), + Some(class) => match executed { + Some((Err(got), _)) if error_matches(e, class, &got) => { + (Some(true), String::new()) + } + Some((Err(got), _)) => (Some(false), error_detail(&got)), + Some((Ok(_), _)) => (Some(false), "no error".to_owned()), + None => (Some(false), "not executed".to_owned()), + }, + }; + let parse_failed = counts_parse && !parsed; + Outcome { + parse: counts_parse.then_some(parsed), + negative, + unclassified: e.error_class.is_none(), + detail: if parse_failed { + format!("{}{why}", parse_detail()) + } else { + why + }, + ..Outcome::default() + } + } } } @@ -433,14 +525,15 @@ fn error_matches(expected: &ExpectedError, class: &str, got: &EngineError) -> bo .is_none_or(|st| got.sql_state.as_ref() == Some(st)) } -fn result_matches( +/// Why `got` does not match the recorded result, or `None` when it does. +fn result_mismatch( s: &Statement, expected_output: &str, got: &QueryOutput, masker: &Masker, -) -> bool { +) -> Option { if got.schema != s.schema { - return false; + return Some(format!("schema {} (want {})", got.schema, s.schema)); } // `getNormalizedQueryExecutionResult`: mask each row, then sort unless the plan is sorted. let mut rows: Vec = got @@ -453,7 +546,26 @@ fn result_matches( rows.sort_unstable_by(|a, b| a.encode_utf16().cmp(b.encode_utf16())); } // `normalizeTestResults` on both sides. - normalize_test_results(&rows.join("\n")) == normalize_test_results(expected_output) + let (got, want) = ( + normalize_test_results(&rows.join("\n")), + normalize_test_results(expected_output), + ); + if got == want { + return None; + } + let clip = |s: Option<&&str>| -> String { + s.map_or_else(|| "".to_owned(), |s| s.chars().take(80).collect()) + }; + // `split` keeps empty segments, so two different texts differ at some segment. + let (g, w): (Vec<&str>, Vec<&str>) = (got.split('\n').collect(), want.split('\n').collect()); + let at = (0..g.len().max(w.len())) + .find(|&i| g.get(i) != w.get(i)) + .unwrap_or_default(); + Some(format!( + "rows differ at row {at}: got `{}`, want `{}`", + clip(g.get(at)), + clip(w.get(at)) + )) } #[cfg(test)] @@ -632,4 +744,96 @@ mod tests { ); Ok(()) } + + #[test] + fn failed_cases_say_why() -> R { + let statements = parse_results(OUT)?; + let mut engine = Canned(vec![ + ( + "select a from t", + Ok(QueryOutput { + schema: "struct".into(), + rows: vec![], + sorted: None, + }), + ), + ("select a from t order by a desc", out(&["2", "3"])), + ("select 1/0", out(&["1"])), + ]); + let f = run_file(&mut engine, "t", &statements, &plain()); + let details: Vec<&str> = f.cases.iter().map(|c| c.detail.as_str()).collect(); + assert_eq!( + details, + [ + "schema struct (want struct)", + "rows differ at row 1: got `3`, want `1`", + "no error", + ] + ); + assert!(f.cases.iter().all(|c| !c.passed())); + assert_eq!( + f.cases.iter().map(|c| c.index).collect::>(), + [0, 1, 2] + ); + let f = run_file(&mut RejectAllEngine, "t", &statements, &plain()); + assert_eq!( + f.cases[0].detail, + "parse failed; error -: RejectAllEngine rejects every statement" + ); + assert_eq!( + f.cases[2].detail, + "parse failed; error -: RejectAllEngine rejects every statement" + ); + Ok(()) + } + + #[test] + fn a_short_result_is_reported_at_its_first_missing_row() -> R { + let statements = parse_results(OUT)?; + let mut engine = Canned(vec![("select a from t order by a desc", out(&["2"]))]); + let f = run_file(&mut engine, "t", &statements, &plain()); + assert_eq!( + f.cases[1].detail, + "rows differ at row 1: got ``, want `1`" + ); + Ok(()) + } + + /// An engine whose sessions cannot be set up. + struct NoSession; + + impl Engine for NoSession { + fn name(&self) -> &str { + "no-session" + } + fn reset(&mut self, _setup: &SessionSetup) -> Result<(), EngineError> { + Err(RejectAllEngine::reject()) + } + fn parse(&mut self, _sql: &str) -> Result<(), EngineError> { + Ok(()) + } + fn execute(&mut self, _sql: &str) -> Result { + Err(RejectAllEngine::reject()) + } + } + + #[test] + fn a_session_that_cannot_start_fails_every_statement_unrun() -> R { + let statements = parse_results(OUT)?; + let f = run_file(&mut NoSession, "t", &statements, &plain()); + let details: Vec<&str> = f.cases.iter().map(|c| c.detail.as_str()).collect(); + assert_eq!( + details, + [ + "parse failed; not executed", + "parse failed; not executed", + "parse failed; not executed" + ] + ); + assert_eq!(f.result.passed + f.negative.passed + f.parse.passed, 0); + let mut e = NoSession; + assert_eq!(e.name(), "no-session"); + assert!(e.parse("x").is_ok() && e.execute("x").is_err()); + Ok(()) + } } diff --git a/crates/krishiv-testkit/src/golden/session_engine.rs b/crates/krishiv-testkit/src/golden/session_engine.rs new file mode 100644 index 000000000..05b10ffdd --- /dev/null +++ b/crates/krishiv-testkit/src/golden/session_engine.rs @@ -0,0 +1,809 @@ +// SPDX-License-Identifier: Apache-2.0 +//! The [`Engine`] over the real query pipeline: a `krishiv-session` [`Session`] per run. +//! +//! * [`Engine::reset`] builds a fresh session with the run's configs and registers the fixture +//! tables the file declares ([`super::fixtures`]). A fixture whose column types the session +//! cannot hold yet (arrays, maps) is not registered; the statements that read it then fail with +//! the analyzer's `TABLE_OR_VIEW_NOT_FOUND`, which is what the engine would answer. +//! * [`Engine::parse`] runs `krishiv-sql`'s statement parser under the session's parser options. +//! * [`Engine::execute`] is `Session::sql` followed by `collect`. `SET key=value` and `RESET` +//! update the session configuration first (so later statements run under the configs Spark +//! used), then go to `Session::sql` like any statement: the session answers commands with its +//! own error, and the statement is scored on that answer. +//! +//! The harness adds no SQL support of its own: everything the score measures is the session's +//! answer. Rows are rendered by [`super::cell`] from the batches and the result's Spark types; +//! row order counts when [`super::sorted::is_semantically_sorted`] says so on the analyzed plan. +//! Each statement runs under a wall-clock limit ([`SessionEngine::with_timeout`]): a statement +//! that exceeds it is cancelled (its future is dropped, which cancels the query) and fails with +//! [`TIMEOUT_CLASS`]. + +use std::sync::Arc; +use std::time::Duration; + +use arrow_array::cast::AsArray as _; +use arrow_array::types::{ + Date32Type, Decimal128Type, Float32Type, Float64Type, Int8Type, Int16Type, Int32Type, + Int64Type, TimestampMicrosecondType, +}; +use arrow_array::{Array, ArrayRef, RecordBatch}; +use arrow_schema::{DataType as ArrowType, Schema}; +use krishiv_common::error::KrishivError; +use krishiv_exec::{Executor, ExecutorConfig, TokioExecutor}; +use krishiv_session::Session; +use krishiv_sql::ParserOptions; +use krishiv_types::DataType; + +use super::cell::{Cell, CellFormat}; +use super::fixtures::{Table, fixtures_dir}; +use super::run::{Engine, EngineError, QueryOutput}; +use super::setup::SessionSetup; +use super::sorted::is_semantically_sorted; + +/// The error class a statement that exceeds the time limit fails with (not a Spark class, so it +/// never matches an expected error). +pub const TIMEOUT_CLASS: &str = "KRISHIV_GOLDEN_TIMEOUT"; + +/// The default per-statement time limit. +pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(30); + +/// The memory limit of each session: far above what any golden statement needs, and below the +/// cap the harness runs under, so a runaway query fails inside the engine. +const SESSION_MEMORY_LIMIT: &str = "4g"; + +/// Runs golden statements through `krishiv-session`. +pub struct SessionEngine { + executor: Arc, + runtime: tokio::runtime::Runtime, + timeout: Duration, + session: Option, + /// The run's configs, and the configs as `SET`/`RESET` statements left them (in order; a + /// later entry for a key overrides an earlier one). + base: Vec<(String, String)>, + conf: Vec<(String, String)>, +} + +impl std::fmt::Debug for SessionEngine { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("SessionEngine") + .field("timeout", &self.timeout) + .finish_non_exhaustive() + } +} + +fn engine_error(e: &KrishivError) -> EngineError { + EngineError { + class: Some(e.error_class().name().to_owned()), + sql_state: e.sql_state().map(str::to_owned), + message: e.message().to_owned(), + } +} + +fn harness_error(message: impl Into) -> EngineError { + EngineError { + class: None, + sql_state: None, + message: message.into(), + } +} + +impl SessionEngine { + /// An engine whose sessions share one executor. + /// + /// # Errors + /// When the executor or the harness's timer runtime cannot start. + pub fn new() -> Result { + let executor: Arc = + TokioExecutor::new(&ExecutorConfig::default()).map_err(|e| engine_error(&e))?; + let runtime = tokio::runtime::Builder::new_current_thread() + .enable_time() + .build() + .map_err(|e| harness_error(format!("timer runtime: {e}")))?; + Ok(Self { + executor, + runtime, + timeout: DEFAULT_TIMEOUT, + session: None, + base: Vec::new(), + conf: Vec::new(), + }) + } + + /// The same engine with a per-statement time limit of `timeout`. + #[must_use] + pub const fn with_timeout(mut self, timeout: Duration) -> Self { + self.timeout = timeout; + self + } + + fn conf_value(&self, key: &str) -> Option<&str> { + self.conf + .iter() + .rev() + .find(|(k, _)| k.eq_ignore_ascii_case(key)) + .map(|(_, v)| v.as_str()) + } + + fn options(&self) -> ParserOptions { + ParserOptions::from_conf(|k| self.conf_value(k)) + } + + /// Mirrors a `SET key=value` or `RESET [key]` statement into the session configuration. + fn apply_set(&mut self, sql: &str) { + let sql = sql.trim().trim_end_matches(';').trim(); + let mut words = sql.split_whitespace(); + let first = words.next().unwrap_or_default(); + if first.eq_ignore_ascii_case("RESET") { + let key = sql.get(5..).map(str::trim).filter(|k| !k.is_empty()); + match key { + None => self.conf.clone_from(&self.base), + Some(key) => { + self.conf.retain(|(k, _)| !k.eq_ignore_ascii_case(key)); + if let Some(kv) = self.base.iter().rev().find(|(k, _)| k == key) { + self.conf.push(kv.clone()); + } + } + } + if let Some(s) = &self.session { + let conf = s.conf(); + match key { + Some(key) => match self.base.iter().rev().find(|(k, _)| k == key) { + Some((k, v)) => drop(conf.set(k, v)), + None => drop(conf.unset(key)), + }, + None => { + for (k, _) in &self.conf { + drop(conf.unset(k)); + } + for (k, v) in &self.base { + drop(conf.set(k, v)); + } + } + } + } + return; + } + if !first.eq_ignore_ascii_case("SET") { + return; + } + if let Some((k, v)) = sql.get(3..).and_then(|rest| rest.split_once('=')) { + let (k, v) = (k.trim().to_owned(), v.trim().to_owned()); + // A key Krishiv does not know is ignored by the session, as Spark keys are. + if let Some(s) = &self.session { + drop(s.conf().set(&k, &v)); + } + self.conf.push((k, v)); + } + } + + fn block_on( + &self, + fut: impl Future>, + ) -> Result { + match self + .runtime + .block_on(async { tokio::time::timeout(self.timeout, fut).await }) + { + Ok(r) => r.map_err(|e| engine_error(&e)), + Err(_) => Err(EngineError { + class: Some(TIMEOUT_CLASS.to_owned()), + sql_state: None, + message: format!("no answer within {:?}", self.timeout), + }), + } + } +} + +impl Engine for SessionEngine { + fn name(&self) -> &str { + "krishiv-session" + } + + fn reset(&mut self, setup: &SessionSetup) -> Result<(), EngineError> { + self.session = None; + let mut builder = Session::builder() + .executor(Arc::clone(&self.executor)) + .config("krishiv.memory.limit", SESSION_MEMORY_LIMIT); + for (k, v) in &setup.configs { + builder = builder.config(k.clone(), v.clone()); + } + // A config Krishiv rejects fails the run's reset: the session's answer. + let session = builder.build().map_err(|e| engine_error(&e))?; + let tables = setup + .load_fixtures(&fixtures_dir()) + .map_err(|e| harness_error(e.to_string()))?; + for table in &tables { + // Not registering a table of types the session cannot hold is the engine's answer + // (see the module docs); any other failure is a harness failure. + if let Some((schema, batch)) = fixture_batch(table)? { + session + .register_batches(&table.name, schema, vec![batch]) + .map_err(|e| engine_error(&e))?; + } + } + self.base.clone_from(&setup.configs); + self.conf.clone_from(&setup.configs); + self.session = Some(session); + Ok(()) + } + + fn parse(&mut self, sql: &str) -> Result<(), EngineError> { + krishiv_sql::parse_statement(sql, &self.options()) + .map(drop) + .map_err(|e| engine_error(&e.error)) + } + + fn execute(&mut self, sql: &str) -> Result { + self.apply_set(sql); + let session = self + .session + .clone() + .ok_or_else(|| harness_error("no session"))?; + let format = CellFormat::for_session(&self.conf).map_err(|e| harness_error(e.to_string())); + let (analyzed, batches) = self.block_on(async { + let df = session.sql(sql).await?; + let analyzed = df.analyzed().await?; + let batches = df.collect().await?; + Ok((analyzed, batches)) + })?; + let format = format?; + let output = &analyzed.output; + let schema = format!( + "struct<{}>", + output + .iter() + .map(|c| format!("{}:{}", c.name, c.data_type.catalog_string())) + .collect::>() + .join(",") + ); + let mut rows = Vec::new(); + for batch in &batches { + // Each column's Spark type, from the batch's own field. + let types = batch + .schema() + .fields() + .iter() + .map(|f| DataType::from_arrow_field(f).map_err(|e| engine_error(&e))) + .collect::, _>>()?; + for row in 0..batch.num_rows() { + let cells = batch + .columns() + .iter() + .zip(&types) + .map(|(col, ty)| arrow_cell(col, row, ty)) + .collect::, _>>()?; + rows.push(format.render_row(&cells)); + } + } + Ok(QueryOutput { + schema, + rows, + sorted: Some(is_semantically_sorted(analyzed.plan.root())), + }) + } +} + +/// The value at `row` of `col`, a column of Spark type `ty`. +fn arrow_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()) + } + // A binary-safe STRING holding bytes that are not UTF-8: Spark's `UTF8String.toString` + // replaces the malformed sequences. + (DataType::String, _) => Cell::Str( + String::from_utf8_lossy(&binary_value(col, row).ok_or_else(unexpected)?).into_owned(), + ), + (DataType::Binary, _) => Cell::Binary(binary_value(col, row).ok_or_else(unexpected)?), + (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)) + } + _ => return Err(unexpected()), + }) +} + +fn binary_value(col: &ArrayRef, row: usize) -> Option> { + Some(match col.data_type() { + ArrowType::BinaryView => col.as_binary_view().value(row).to_vec(), + ArrowType::Binary => col.as_binary::().value(row).to_vec(), + ArrowType::LargeBinary => col.as_binary::().value(row).to_vec(), + _ => return None, + }) +} + +/// A fixture table as one batch, or `None` when a column type is one the session cannot hold. +fn fixture_batch(table: &Table) -> Result, RecordBatch)>, EngineError> { + let mut fields = Vec::with_capacity(table.columns.len()); + let mut types = Vec::with_capacity(table.columns.len()); + for c in &table.columns { + let Ok(ty) = krishiv_types::parse_data_type(&c.spark_type) else { + return Ok(None); + }; + fields.push(ty.to_arrow_field(&c.name, c.nullable)); + types.push(ty); + } + let schema = Arc::new(Schema::new(fields)); + let columns = types + .iter() + .enumerate() + .map(|(i, ty)| fixture_column(table, i, ty)) + .collect::, _>>()?; + let batch = RecordBatch::try_new(Arc::clone(&schema), columns) + .map_err(|e| harness_error(format!("fixture `{}`: {e}", table.name)))?; + Ok(Some((schema, batch))) +} + +fn fixture_column(table: &Table, i: usize, ty: &DataType) -> Result { + use arrow_array::builder::{ + BinaryViewBuilder, BooleanBuilder, Date32Builder, Decimal128Builder, Float32Builder, + Float64Builder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, StringViewBuilder, + TimestampMicrosecondBuilder, + }; + let cells = table.rows.iter().map(|r| r.get(i).unwrap_or(&Cell::Null)); + let bad = |c: &Cell| { + harness_error(format!( + "fixture `{}` column {i}: {c:?} for {}", + table.name, + ty.catalog_string() + )) + }; + macro_rules! ints { + ($builder:ty, $t:ty) => {{ + let mut b = <$builder>::new(); + for c in cells { + match c { + Cell::Null => b.append_null(), + Cell::Int(v) => b.append_value(<$t>::try_from(*v).map_err(|_| bad(c))?), + other => return Err(bad(other)), + } + } + Arc::new(b.finish()) as ArrayRef + }}; + } + Ok(match ty { + DataType::Byte => ints!(Int8Builder, i8), + DataType::Short => ints!(Int16Builder, i16), + DataType::Integer => ints!(Int32Builder, i32), + DataType::Long => ints!(Int64Builder, i64), + DataType::Boolean => { + let mut b = BooleanBuilder::new(); + for c in cells { + match c { + Cell::Null => b.append_null(), + Cell::Bool(v) => b.append_value(*v), + other => return Err(bad(other)), + } + } + Arc::new(b.finish()) + } + DataType::Float => { + let mut b = Float32Builder::new(); + for c in cells { + match c { + Cell::Null => b.append_null(), + Cell::Float(v) => b.append_value(*v), + other => return Err(bad(other)), + } + } + Arc::new(b.finish()) + } + DataType::Double => { + let mut b = Float64Builder::new(); + for c in cells { + match c { + Cell::Null => b.append_null(), + Cell::Double(v) => b.append_value(*v), + other => return Err(bad(other)), + } + } + Arc::new(b.finish()) + } + DataType::Decimal(d) => { + let mut b = Decimal128Builder::new(); + for c in cells { + match c { + Cell::Null => b.append_null(), + Cell::Decimal(v, _) => b.append_value(*v), + other => return Err(bad(other)), + } + } + let ArrowType::Decimal128(p, s) = ty.to_arrow() else { + return Err(bad(&Cell::Null)); + }; + let _ = d; + Arc::new( + b.finish() + .with_precision_and_scale(p, s) + .map_err(|e| harness_error(e.to_string()))?, + ) + } + DataType::String => { + let mut b = StringViewBuilder::new(); + for c in cells { + match c { + Cell::Null => b.append_null(), + Cell::Str(v) => b.append_value(v), + other => return Err(bad(other)), + } + } + Arc::new(b.finish()) + } + DataType::Binary => { + let mut b = BinaryViewBuilder::new(); + for c in cells { + match c { + Cell::Null => b.append_null(), + Cell::Binary(v) => b.append_value(v), + other => return Err(bad(other)), + } + } + Arc::new(b.finish()) + } + DataType::Date => { + let mut b = Date32Builder::new(); + for c in cells { + match c { + Cell::Null => b.append_null(), + Cell::Date(v) => b.append_value(*v), + other => return Err(bad(other)), + } + } + Arc::new(b.finish()) + } + DataType::Timestamp | DataType::TimestampNtz => { + let mut b = TimestampMicrosecondBuilder::new(); + for c in cells { + match c { + Cell::Null => b.append_null(), + Cell::Timestamp(v) | Cell::TimestampNtz(v) => b.append_value(*v), + other => return Err(bad(other)), + } + } + let arr = b.finish(); + match ty.to_arrow() { + ArrowType::Timestamp(_, Some(tz)) => Arc::new(arr.with_timezone(tz)), + _ => Arc::new(arr), + } + } + DataType::Null => Arc::new(arrow_array::NullArray::new(table.rows.len())), + other => { + return Err(harness_error(format!( + "fixture `{}`: type {}", + table.name, + other.catalog_string() + ))); + } + }) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::golden::setup::{Fixture, TestKind}; + + type R = Result<(), Box>; + + fn engine(fixtures: Vec) -> Result { + let mut e = SessionEngine::new()?; + let mut setup = SessionSetup::plain(TestKind::of("t")); + setup.fixtures = fixtures; + e.reset(&setup)?; + Ok(e) + } + + #[expect( + clippy::needless_pass_by_value, + reason = "used as `map_err(err)`, which passes the error by value" + )] + fn err(e: EngineError) -> Box { + format!("{e:?}").into() + } + + #[test] + fn renders_rows_schema_and_sortedness() -> R { + let mut e = engine(vec![]).map_err(err)?; + let out = e + .execute( + "SELECT 1 AS i, CAST(2 AS TINYINT) AS b, CAST(3 AS SMALLINT) AS s, 4L AS l, \ + CAST(1.5 AS FLOAT) AS f, 2.5D AS d, 1.50BD AS m, 'x' AS t, X'4142' AS y, \ + DATE'2020-01-02' AS dt, CAST('2020-01-02 03:04:05' AS TIMESTAMP_NTZ) AS n, true AS z, \ + CAST(NULL AS INT) AS u", + ) + .map_err(err)?; + assert_eq!( + out.schema, + "struct" + ); + assert_eq!( + out.rows, + [[ + "1", + "2", + "3", + "4", + "1.5", + "2.5", + "1.50", + "x", + "AB", + "2020-01-02", + "2020-01-02 03:04:05", + "true", + "NULL" + ]] + ); + assert_eq!(out.sorted, Some(false)); + let sorted = e.execute("SELECT 2 AS a ORDER BY a").map_err(err)?; + assert_eq!(sorted.sorted, Some(true)); + Ok(()) + } + + #[test] + fn errors_carry_the_class_and_parse_uses_the_session_options() -> R { + let mut e = engine(vec![]).map_err(err)?; + let got = e.execute("SELECT * FROM missing").map(drop).unwrap_err(); + assert_eq!(got.class.as_deref(), Some("TABLE_OR_VIEW_NOT_FOUND")); + assert_eq!(got.sql_state.as_deref(), Some("42P01")); + assert!(e.parse("SELECT 1").is_ok()); + let got = e.parse("SELEC 1").unwrap_err(); + assert_eq!(got.class.as_deref(), Some("PARSE_SYNTAX_ERROR")); + // `"a"` is a string, until double-quoted identifiers are on. + assert!(e.parse("SELECT \"a\" FROM t").is_ok()); + e.apply_set("SET spark.sql.ansi.doubleQuotedIdentifiers = true;"); + assert_eq!( + e.conf_value("SPARK.SQL.ANSI.DOUBLEQUOTEDIDENTIFIERS"), + Some("true") + ); + assert!(e.options().double_quoted_identifiers); + e.apply_set("RESET spark.sql.ansi.doubleQuotedIdentifiers"); + assert!(!e.options().double_quoted_identifiers); + Ok(()) + } + + #[test] + fn set_and_reset_reach_the_session() -> R { + let mut e = engine(vec![]).map_err(err)?; + let ts = |e: &mut SessionEngine| -> Result> { + let out = e + .execute("SELECT CAST('2020-01-01 00:00:00' AS TIMESTAMP) AS t") + .map_err(err)?; + Ok(out.rows[0][0].clone()) + }; + e.apply_set("SET spark.sql.session.timeZone=UTC"); + // The command itself is the session's answer: it does not parse yet. + let set = e + .execute("SET spark.sql.session.timeZone=+01:00") + .map(drop) + .unwrap_err(); + assert_eq!(set.class.as_deref(), Some("PARSE_SYNTAX_ERROR")); + assert_eq!(ts(&mut e)?, "2020-01-01 00:00:00"); + e.apply_set("RESET spark.sql.session.timeZone"); + e.apply_set("SET spark.sql.session.timeZone=UTC"); + e.apply_set("RESET"); + assert_eq!(e.conf, e.base); + e.apply_set("SET spark.sql.session.timeZone"); + assert_eq!(e.conf, e.base); + Ok(()) + } + + #[test] + fn fixtures_with_session_types_are_registered() -> R { + let mut e = engine(vec![ + Fixture::TestData, + Fixture::ArrayData, + Fixture::AggTest, + ]) + .map_err(err)?; + let out = e + .execute("SELECT count(*), max(key), min(value) FROM testdata") + .map_err(err)?; + assert_eq!(out.rows, [["100", "100", "1"]]); + let out = e + .execute("SELECT sum(a), max(b) FROM aggtest") + .map_err(err)?; + assert_eq!(out.rows, [["198", "324.78"]]); + // `arraydata` has array columns, which the session cannot hold yet. + let got = e.execute("SELECT * FROM arraydata").map(drop).unwrap_err(); + assert_eq!(got.class.as_deref(), Some("TABLE_OR_VIEW_NOT_FOUND")); + Ok(()) + } + + #[test] + fn a_statement_past_the_time_limit_fails_with_the_timeout_class() -> R { + let e = SessionEngine::new() + .map_err(err)? + .with_timeout(Duration::ZERO); + let got = e + .block_on(std::future::pending::>()) + .unwrap_err(); + assert_eq!(got.class.as_deref(), Some(TIMEOUT_CLASS)); + assert!(format!("{e:?}").contains("timeout")); + let mut idle = SessionEngine::new().map_err(err)?; + assert_eq!( + idle.execute("SELECT 1").map(drop).unwrap_err().message, + "no session" + ); + assert_eq!(idle.name(), "krishiv-session"); + Ok(()) + } + + #[test] + fn cells_follow_the_spark_type_not_only_the_arrow_type() -> R { + use arrow_array::{BinaryArray, Int32Array, LargeStringArray, StringArray}; + let s: ArrayRef = Arc::new(StringArray::from(vec!["a"])); + assert_eq!( + arrow_cell(&s, 0, &DataType::String).map_err(err)?, + Cell::Str("a".into()) + ); + let s: ArrayRef = Arc::new(LargeStringArray::from(vec!["b"])); + assert_eq!( + arrow_cell(&s, 0, &DataType::String).map_err(err)?, + Cell::Str("b".into()) + ); + // A binary-safe STRING holding bytes that are not UTF-8. + let b: ArrayRef = Arc::new(BinaryArray::from(vec![&b"a\xff"[..]])); + assert_eq!( + arrow_cell(&b, 0, &DataType::String).map_err(err)?, + Cell::Str("a\u{fffd}".into()) + ); + assert_eq!( + arrow_cell(&b, 0, &DataType::Binary).map_err(err)?, + Cell::Binary(b"a\xff".to_vec()) + ); + let i: ArrayRef = Arc::new(Int32Array::from(vec![1])); + assert_eq!(arrow_cell(&i, 0, &DataType::Null).map_err(err)?, Cell::Null); + let bad = arrow_cell(&i, 0, &DataType::String).unwrap_err(); + assert!( + bad.message.contains("Arrow type Int32 for string"), + "{}", + bad.message + ); + assert!(arrow_cell(&i, 0, &DataType::Binary).is_err()); + Ok(()) + } + + #[test] + fn fixture_tables_of_every_session_type_round_trip() -> R { + use crate::golden::fixtures::{Column, Table}; + let col = |name: &str, ty: &str| Column { + name: name.into(), + spark_type: ty.into(), + nullable: true, + }; + let table = Table { + name: "every".into(), + columns: vec![ + col("b", "tinyint"), + col("s", "smallint"), + col("i", "int"), + col("l", "bigint"), + col("z", "boolean"), + col("f", "float"), + col("d", "double"), + col("m", "decimal(5,2)"), + col("t", "string"), + col("y", "binary"), + col("dt", "date"), + col("ts", "timestamp"), + col("n", "timestamp_ntz"), + col("v", "void"), + ], + rows: vec![ + vec![ + Cell::Int(1), + Cell::Int(2), + Cell::Int(3), + Cell::Int(4), + Cell::Bool(true), + Cell::Float(1.5), + Cell::Double(2.5), + Cell::Decimal(150, 2), + Cell::Str("x".into()), + Cell::Binary(b"ab".to_vec()), + Cell::Date(1), + Cell::Timestamp(1_000_000), + Cell::TimestampNtz(2_000_000), + Cell::Null, + ], + vec![Cell::Null; 14], + ], + }; + let (schema, batch) = fixture_batch(&table) + .map_err(err)? + .ok_or("not registered")?; + assert_eq!(batch.num_rows(), 2); + let types = schema + .fields() + .iter() + .map(|f| DataType::from_arrow_field(f)) + .collect::, _>>()?; + let back = |row: usize| -> Result, EngineError> { + batch + .columns() + .iter() + .zip(&types) + .map(|(c, t)| arrow_cell(c, row, t)) + .collect() + }; + assert_eq!(back(0).map_err(err)?, table.rows[0]); + assert_eq!(back(1).map_err(err)?, table.rows[1]); + // A cell of the wrong kind, or out of the column type's range, is a harness error. + for (ty, cell) in [ + ("tinyint", Cell::Int(300)), + ("int", Cell::Str("x".into())), + ("boolean", Cell::Int(1)), + ("float", Cell::Int(1)), + ("double", Cell::Int(1)), + ("decimal(5,2)", Cell::Int(1)), + ("string", Cell::Int(1)), + ("binary", Cell::Int(1)), + ("date", Cell::Int(1)), + ("timestamp", Cell::Int(1)), + ] { + let bad = Table { + name: "bad".into(), + columns: vec![col("c", ty)], + rows: vec![vec![cell]], + }; + let e = fixture_batch(&bad).map(drop).unwrap_err(); + assert!( + e.message.contains("fixture `bad` column 0"), + "{ty}: {}", + e.message + ); + } + // Nested columns: the table is not registered. + let nested = Table { + name: "n".into(), + columns: vec![col("a", "array")], + rows: vec![], + }; + assert!(fixture_batch(&nested).map_err(err)?.is_none()); + Ok(()) + } +} diff --git a/crates/krishiv-testkit/tests/golden_ratchet.rs b/crates/krishiv-testkit/tests/golden_ratchet.rs new file mode 100644 index 000000000..e4aa22ccf --- /dev/null +++ b/crates/krishiv-testkit/tests/golden_ratchet.rs @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: Apache-2.0 +//! The Spark golden-file ratchet: the whole vendored Spark 4.2 `SQLQueryTestSuite` runs through +//! `krishiv-session`, and the statements that do not pass must be exactly those of the frozen +//! baseline `tests/spark-golden/known-failures.json`. A statement that newly fails is a +//! regression; a listed statement that passes must leave the list (it only shrinks). Refresh +//! the list with `cargo run -p krishiv-testkit --bin golden-report -- --engine session +//! --ratchet update`. +#![forbid(unsafe_code)] + +use krishiv_testkit::golden::known_failures::KnownFailures; +use krishiv_testkit::golden::manifest::ExclusionManifest; +use krishiv_testkit::golden::run::run; +use krishiv_testkit::golden::session_engine::SessionEngine; +use krishiv_testkit::golden::{DEFAULT_TAG, GoldenSet}; + +type R = Result<(), Box>; + +#[test] +fn session_engine_matches_the_frozen_baseline() -> R { + let known = KnownFailures::load(&KnownFailures::default_path())?; + assert_eq!(known.spark_tag, DEFAULT_TAG); + let unused = known.unused_categories(); + assert!(unused.is_empty(), "categories without cases: {unused:?}"); + let manifest = ExclusionManifest::load(&ExclusionManifest::default_path())?; + assert!(manifest.frozen, "the exclusion manifest is frozen"); + let set = GoldenSet::scan(&GoldenSet::tag_dir(DEFAULT_TAG))?; + let mut engine = SessionEngine::new().map_err(|e| e.message)?; + let result = run(&mut engine, &set, &manifest)?; + assert!(result.failed_files.is_empty(), "{:?}", result.failed_files); + let ratchet = known.check(&result); + assert!(ratchet.is_clean(), "{}", ratchet.describe()); + Ok(()) +} diff --git a/crates/krishiv-testkit/tests/golden_report.rs b/crates/krishiv-testkit/tests/golden_report.rs index faa5a6db5..cf453e943 100644 --- a/crates/krishiv-testkit/tests/golden_report.rs +++ b/crates/krishiv-testkit/tests/golden_report.rs @@ -56,3 +56,41 @@ fn unknown_engine_is_a_usage_error() -> R { assert!(stderr.contains("--engine reject-all|sql-parse"), "{stderr}"); Ok(()) } + +#[test] +fn ratchet_flags_are_checked() -> R { + let (ok, _, stderr) = report(&["--ratchet", "check"])?; + assert!(!ok); + assert!( + stderr.contains("--ratchet needs --engine session"), + "{stderr}" + ); + let (ok, _, stderr) = report(&["--engine", "session", "--ratchet", "maybe"])?; + assert!(!ok); + assert!(stderr.contains("[--ratchet check|update]"), "{stderr}"); + Ok(()) +} + +#[test] +fn reject_all_writes_every_failing_case() -> R { + let cases = Path::new(env!("CARGO_TARGET_TMPDIR")).join("golden-reject-all-cases.json"); + let (ok, _, stderr) = report(&[ + "--engine", + "reject-all", + "--cases", + &cases.to_string_lossy(), + "--known-failures", + "unused.json", + ])?; + assert!(ok, "{stderr}"); + let json: serde_json::Value = serde_json::from_str(&std::fs::read_to_string(&cases)?)?; + let first = &json["array"][0]; + assert_eq!(first["index"], 0); + assert!( + first["detail"] + .as_str() + .is_some_and(|d| d.contains("RejectAllEngine")), + "{first}" + ); + Ok(()) +} diff --git a/tests/spark-golden/exclusions.json b/tests/spark-golden/exclusions.json index 5f0c750e1..9b8428d9a 100644 --- a/tests/spark-golden/exclusions.json +++ b/tests/spark-golden/exclusions.json @@ -1,5 +1,5 @@ { "format_version": 1, - "frozen": false, + "frozen": true, "exclusions": [] } diff --git a/tests/spark-golden/known-failures.json b/tests/spark-golden/known-failures.json new file mode 100644 index 000000000..dc4e0e2b4 --- /dev/null +++ b/tests/spark-golden/known-failures.json @@ -0,0 +1,815 @@ +{ + "categories": { + "analyzer-bugs": { + "kind": "bug", + "owner": "analyzer follow-up of P2-T071a", + "summary": "analyzer resolution differs from Spark: unused CTE definitions are analyzed (cte#50), GROUP BY a backquoted output alias `1`, LIMIT over a column reports UNRESOLVED_COLUMN instead of IS_UNFOLDABLE" + }, + "cast-matrix": { + "kind": "unsupported", + "summary": "the full cast matrix: casts not in P2a, cast-named functions, region time zones", + "task": "P2-T021b" + }, + "coercion": { + "kind": "unsupported", + "summary": "full Spark type coercion (implicit string casts with ANSI off)", + "task": "P2-T071d" + }, + "conditional-physical": { + "kind": "bug", + "owner": "physical planner follow-up of P2-T074", + "summary": "coalesce/if/nvl/nvl2/nullif/ifnull/zeroifnull/nullifzero resolve but are not bound in physical plans" + }, + "datetime": { + "kind": "unsupported", + "summary": "datetime functions and literals beyond P2a (TIMESTAMP literals, date/timestamp arithmetic, patterns, unit-argument forms)", + "task": "P2-T025" + }, + "datetime-bugs": { + "kind": "bug", + "owner": "datetime follow-up of P2-T025a", + "summary": "date_add/date_sub accept a fractional string day count with ANSI off; Spark raises SECOND_FUNCTION_ARGUMENT_NOT_INTEGER" + }, + "depends-on-command": { + "kind": "unsupported", + "summary": "queries that read a table, view, function or variable an earlier command of the file creates (the command failed, so the query fails or reads the shared fixture of the same name)", + "task": "P2-T179" + }, + "files": { + "kind": "unsupported", + "summary": "partitioned and glob reads of directories", + "task": "P2-T082b" + }, + "fn-aggregate": { + "kind": "unsupported", + "summary": "aggregate and sketch functions beyond P2a, WITHIN GROUP", + "task": "P2-T032" + }, + "fn-array": { + "kind": "unsupported", + "summary": "array and collection functions", + "task": "P2-T028" + }, + "fn-bitwise-predicate": { + "kind": "unsupported", + "summary": "bitwise and predicate functions", + "task": "P2-T037" + }, + "fn-json": { + "kind": "unsupported", + "summary": "JSON functions", + "task": "P2-T031" + }, + "fn-map": { + "kind": "unsupported", + "summary": "map functions", + "task": "P2-T029" + }, + "fn-misc": { + "kind": "unsupported", + "summary": "misc functions (typeof, uuid, rand, raise_error, vector, current_*)", + "task": "P2-T035" + }, + "fn-number-format": { + "kind": "unsupported", + "summary": "number formatting: to_number, to_char, format_number", + "task": "P2-T039" + }, + "fn-regex": { + "kind": "unsupported", + "summary": "regular-expression functions and operators", + "task": "P2-T024" + }, + "fn-string": { + "kind": "unsupported", + "summary": "string and math-tail functions not in P2a (hex, conv, bin, width_bucket, ...)", + "task": "P2-T023" + }, + "fn-struct": { + "kind": "unsupported", + "summary": "struct functions", + "task": "P2-T030" + }, + "fn-url-xml-csv": { + "kind": "unsupported", + "summary": "URL, XML, CSV and protobuf functions", + "task": "P2-T038" + }, + "generators": { + "kind": "unsupported", + "summary": "generators: explode, LATERAL VIEW, multi-name aliases, stack, inline", + "task": "P2-T034" + }, + "grouping-sets": { + "kind": "unsupported", + "summary": "ROLLUP, CUBE, GROUPING SETS, grouping()/grouping_id()", + "task": "P2-T053b" + }, + "hof": { + "kind": "unsupported", + "summary": "lambda functions and higher-order functions", + "task": "P2-T036" + }, + "legacy-configs": { + "kind": "bug", + "owner": "config map follow-up of P2-T004", + "summary": "legacy behaviour flags the session ignores instead of rejecting (ctePrecedencePolicy, consecutiveStringLiterals, allowStarWithSingleTableIdentifierInCount, allowParameterlessCount)" + }, + "nested-interval-types": { + "kind": "unsupported", + "summary": "nested types, intervals, CHAR/VARCHAR, struct constructors, subscripts and field access", + "task": "P2-T001b" + }, + "object-stores": { + "kind": "unsupported", + "summary": "remote paths (https and object stores)", + "task": "P2-T084" + }, + "output-names": { + "kind": "bug", + "owner": "analyzer output-name follow-up of P2-T071a", + "summary": "auto-generated column names differ from Spark's toPrettySQL (Java float/decimal text, default arguments, TRIM/CEIL/LOG/mod spellings, +year dates)" + }, + "parser-pipe-collate": { + "kind": "unsupported", + "summary": "pipe syntax |> and COLLATE / collations", + "task": "P2-T075b" + }, + "parser-tail": { + "kind": "unsupported", + "summary": "TRANSFORM, IDENTIFIER(), TABLE(...) arguments, TABLESAMPLE, NEAREST BY, variant paths", + "task": "P2-T075c" + }, + "query-features": { + "kind": "unsupported", + "summary": "query features the analyzer or planner lacks: inline VALUES, table-valued functions, NATURAL and USING joins, recursive CTEs, LATERAL, PIVOT/UNPIVOT, OFFSET, GROUP BY ALL, SELECT * EXCEPT, QUALIFY, named and qualified function names, LIKE ANY/ALL, aggregate FILTER, multi-SELECT FROM", + "task": "P2-T180" + }, + "sql-commands": { + "kind": "unsupported", + "summary": "SQL commands (DDL, DML, SET/RESET, DESCRIBE/SHOW, session variables, EXECUTE IMMEDIATE, SQL functions): not parsed or executed by the session yet", + "task": "P2-T179" + }, + "subqueries": { + "kind": "unsupported", + "summary": "general subquery unnesting (correlated shapes beyond TPC-H)", + "task": "P2-T115" + }, + "test-udfs": { + "kind": "unsupported", + "summary": "the suite's Python/Scala test UDFs (udf/, udaf/, udtf/ folders)", + "task": "P2-T059" + }, + "time-geo-types": { + "kind": "unsupported", + "summary": "Spark 4.x TIME type and literals; GEOMETRY/GEOGRAPHY types and ST functions", + "task": "P2-T181" + }, + "variant-type": { + "kind": "unsupported", + "summary": "the VARIANT type", + "task": "P2-T001c" + }, + "window": { + "kind": "unsupported", + "summary": "window functions and WINDOW clauses", + "task": "P2-T055" + } + }, + "format_version": 1, + "frozen_at": "2026-10-22", + "rules": [ + { + "category": "sql-commands", + "command": true + }, + { + "category": "legacy-configs", + "file": "^cte-(legacy|nonlegacy)$" + }, + { + "category": "legacy-configs", + "detail": "^rows differ", + "file": "literals$", + "query": "\\\"S\\\"\\\"par|'S''par" + }, + { + "category": "legacy-configs", + "detail": "^no error|WRONG_NUM_ARGS", + "file": "^count$" + }, + { + "category": "depends-on-command", + "depends": true + }, + { + "category": "test-udfs", + "file": "^(udf|udaf|udtf)/" + }, + { + "category": "test-udfs", + "detail": "Cannot resolve routine `(udf|udaf|vol|booleq|boolne)`" + }, + { + "category": "sql-commands", + "query": "(?i)^\\s*explain\\s+(extended\\s+|formatted\\s+)?(desc|describe|show|create|insert|set)\\b" + }, + { + "category": "depends-on-command", + "detail": "TABLE_OR_VIEW_NOT_FOUND.*`(tab_renamed)`" + }, + { + "category": "time-geo-types", + "file": "^st-functions$" + }, + { + "category": "parser-tail", + "file": "^transform$" + }, + { + "category": "analyzer-bugs", + "detail": "AMBIGUOUS_REFERENCE", + "file": "^cte$" + }, + { + "category": "analyzer-bugs", + "detail": "UNRESOLVED_COLUMN.*`1`", + "file": "^group-by-alias$" + }, + { + "category": "analyzer-bugs", + "detail": "UNRESOLVED_COLUMN.*`key`", + "file": "^limit$" + }, + { + "category": "datetime-bugs", + "detail": "^no error", + "file": "^nonansi/date$" + }, + { + "category": "datetime", + "detail": "WRONG_NUM_ARGS.*`(date_add|dateadd|datediff|date_diff)`|Cannot resolve routine `(timestampadd|timestampdiff|timediff)`" + }, + { + "category": "datetime", + "detail": "INVALID_TYPED_LITERAL", + "file": "^postgreSQL/date$" + }, + { + "category": "subqueries", + "detail": "list-query|UNRESOLVED_COLUMN.*`a`\\.`four`" + }, + { + "category": "parser-pipe-collate", + "query": "(?i)\\|>|\\bcollat(e|ion)\\b|\\|\\s*(select|where|aggregate|extend|set|drop|as|join|union|order|limit|pivot)\\b" + }, + { + "category": "parser-pipe-collate", + "file": "^(pipe-operators|collations)" + }, + { + "category": "parser-tail", + "detail": "^parse failed", + "query": "(?i)\\b(transform|identifier|tablesample|nearest)\\b|\\btable\\s*\\(|:\\w" + }, + { + "category": "conditional-physical", + "detail": "The feature the expression (coalesce|if|nvl|nvl2|nullif|ifnull|zeroifnull|nullifzero)\\(" + }, + { + "category": "fn-string", + "detail": "The feature the operator ilike" + }, + { + "category": "fn-regex", + "detail": "The feature the operator rlike" + }, + { + "category": "query-features", + "detail": "The feature (VALUES|table-valued functions|NATURAL JOIN|recursive CTEs|LATERAL subqueries|LATERAL joins|PIVOT and UNPIVOT|OFFSET|SELECT \\* EXCEPT|qualified function names|named function arguments|LIKE ANY|FROM with several SELECT|QUALIFY|aggregate FILTER|DISTINCT aggregates over different|JOIN \\.\\.\\. USING)" + }, + { + "category": "query-features", + "detail": "UNRESOLVED_COLUMN.*`ALL`" + }, + { + "category": "nested-interval-types", + "detail": "The feature (INTERVAL literals|interval data types|nested data types|row and struct constructors|subscripts|field access|char/varchar)" + }, + { + "category": "nested-interval-types", + "detail": "INVALID_EXTRACT_BASE_FIELD_TYPE|interval literals in physical plans" + }, + { + "category": "nested-interval-types", + "detail": "TABLE_OR_VIEW_NOT_FOUND.*`(arraydata|mapdata)`" + }, + { + "category": "variant-type", + "detail": "The feature the variant data type" + }, + { + "category": "time-geo-types", + "detail": "The feature (TIME literals|the time data type)" + }, + { + "category": "datetime", + "detail": "The feature (TIMESTAMP|TIMESTAMP_NTZ|TIMESTAMP_LTZ) literals|The feature date and timestamp arithmetic" + }, + { + "category": "cast-matrix", + "detail": "The feature (functions of timestamps in a session time zone|casts that read a session time zone|CAST from )" + }, + { + "category": "coercion", + "detail": "The feature implicit string casts" + }, + { + "category": "window", + "detail": "The feature (window functions|WINDOW clauses)" + }, + { + "category": "grouping-sets", + "detail": "The feature ROLLUP" + }, + { + "category": "subqueries", + "detail": "The feature correlated scalar subqueries" + }, + { + "category": "files", + "detail": "The feature (glob patterns|reading the subdirectory)" + }, + { + "category": "object-stores", + "detail": "The feature paths with the scheme" + }, + { + "category": "generators", + "detail": "The feature (multi-name aliases|LATERAL VIEW)" + }, + { + "category": "hof", + "detail": "The feature lambda functions" + }, + { + "category": "fn-aggregate", + "detail": "The feature WITHIN GROUP" + }, + { + "category": "fn-number-format", + "detail": "(The feature function |Cannot resolve routine `)(?i)(to_number|try_to_number|to_char|to_varchar|format_number)\\b" + }, + { + "category": "fn-regex", + "detail": "(The feature function |Cannot resolve routine `)(?i)(regexp\\w*|rlike|split)\\b" + }, + { + "category": "fn-string", + "family": [ + "string", + "math" + ] + }, + { + "category": "datetime", + "family": [ + "datetime" + ] + }, + { + "category": "cast-matrix", + "family": [ + "conversion" + ] + }, + { + "category": "fn-aggregate", + "family": [ + "agg", + "sketch" + ] + }, + { + "category": "fn-array", + "family": [ + "array", + "collection" + ] + }, + { + "category": "fn-map", + "family": [ + "map" + ] + }, + { + "category": "fn-struct", + "family": [ + "struct" + ] + }, + { + "category": "fn-json", + "family": [ + "json" + ] + }, + { + "category": "generators", + "family": [ + "generator", + "table" + ] + }, + { + "category": "fn-misc", + "family": [ + "misc", + "vector", + "hash", + "conditional" + ] + }, + { + "category": "hof", + "family": [ + "lambda" + ] + }, + { + "category": "fn-bitwise-predicate", + "family": [ + "bitwise", + "predicate", + "operators" + ] + }, + { + "category": "fn-url-xml-csv", + "family": [ + "url", + "xml", + "csv", + "protobuf" + ] + }, + { + "category": "time-geo-types", + "family": [ + "st" + ] + }, + { + "category": "output-names", + "detail": "^schema " + } + ], + "spark_tag": "v4.2.0", + "cases": { + "alias-resolution-edge-cases": {"depends-on-command":[6,7],"fn-string":[2,3],"query-features":[4,5],"sql-commands":[0,1,8,9]}, + "array": {"depends-on-command":[1,2,3,5,6,7,8,11],"fn-array":[9,10,12,13,14,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,59,60,63,64,65,66,67,68,69,70,71,74,76,77,78,79,80,83,85,86,87],"fn-string":[15,16,17,18,19,20,21],"nested-interval-types":[22,23,52,72,73,75,81,82,84],"query-features":[62],"sql-commands":[0,4,58,61]}, + "binary": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, + "binary_base64": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, + "binary_basic": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, + "binary_hex": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, + "binary_hex_discrete": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, + "bitwise": {"depends-on-command":[21,22,23,24,25,26],"fn-bitwise-predicate":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,27,28,29,30,31,32,33,34,43,44,45],"nested-interval-types":[40,41,42],"sql-commands":[20]}, + "cast": {"cast-matrix":[58,59,60,66,67,70,71,130,131],"fn-string":[28,29,30,31,32,33,34,35,36,124,125],"nested-interval-types":[39,40,41,43,44,72,73,74,75,76,77,78,79,80,81,82,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,126,127,132,133,134,135,143],"query-features":[83,87],"sql-commands":[37,38],"time-geo-types":[104,105,106,107,108,109,110,111,112,113,114,115,116,136,137,138,139,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163]}, + "change-column": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27]}, + "charvarchar": {"depends-on-command":[50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80],"fn-number-format":[87,88,89],"fn-string":[85,86],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,81,82,83,84]}, + "collations-aliases": {"depends-on-command":[16,17,18,19,20,21,22,23,24,25,26,28,29],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,27,30,31]}, + "collations-basic": {"depends-on-command":[8,9,10,11,12,13,14,18,34,35,59,60,61,62,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132],"parser-pipe-collate":[21,22,23,24,25,26,27,28,29,30,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56],"sql-commands":[0,1,2,3,4,5,6,7,15,16,17,19,20,31,32,33,36,57,58,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,133,134,135,136]}, + "collations-padding-trim": {"depends-on-command":[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,68]}, + "collations-string-functions": {"depends-on-command":[21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,148,149,150]}, + "column-resolution-aggregate": {"depends-on-command":[2,3,4,5,6,7,8,9,10],"sql-commands":[0,1]}, + "column-resolution-sort": {"depends-on-command":[2,3,4],"sql-commands":[0,1]}, + "columnresolution": {"depends-on-command":[7,8,9,10,11,12,14,15,16,17,18,20,21,22,24,25,26,27,31,32,34,35,37,42,43,44,45,46,47,48,49,50,51],"sql-commands":[0,1,2,3,4,5,6,13,19,23,28,29,30,33,36,38,39,40,41,52,53,54]}, + "columnresolution-negative": {"depends-on-command":[8,9,10,11,12,14,15,16,17,18,21,22,23,25,30,35],"sql-commands":[0,1,2,3,4,5,6,7,13,19,20,24,26,27,28,29,31,32,33,34,36,37]}, + "columnresolution-views": {"depends-on-command":[1,2,3,4,5,6,9,10,11,12,13,14,15],"sql-commands":[0,7,8,16]}, + "conditional-functions": {"conditional-physical":[5,6,8,9,13,14,15,16],"depends-on-command":[1,2,3,4,7,10],"sql-commands":[0,17]}, + "count": {"depends-on-command":[1,2,3,4,8,9,10,11,12,18],"legacy-configs":[14,16,20],"sql-commands":[0,13,15,17,19]}, + "cross-join": {"depends-on-command":[2,3,4,5,6,11,12],"sql-commands":[0,1,7,8,9,10]}, + "csv-functions": {"depends-on-command":[13],"fn-url-xml-csv":[0,1,2,3,4,5,6,7,8,9,10,11,15,16,17,18,19,20,21,22,33,34,35,36,37,38],"sql-commands":[12,14],"time-geo-types":[23,24,25,26,27,28,29,30,31,32]}, + "cte": {"analyzer-bugs":[50],"depends-on-command":[6,7,9,10,19,23,31,32,36,45,46,47,48],"fn-misc":[22],"query-features":[17,41,42,43],"sql-commands":[0,1,2,3,51,52,53,54],"subqueries":[27]}, + "cte-command": {"depends-on-command":[1,3,4,5,7,9,10,11],"sql-commands":[0,2,6,8,12,13]}, + "cte-legacy": {"legacy-configs":[3,4,5,6,7,8,12,13,14,15,17,18,19,21]}, + "cte-nested": {"query-features":[3,4,5]}, + "cte-nonlegacy": {"legacy-configs":[3,4,5,6,8,12,13,14,15,17,18]}, + "cte-recursion": {"depends-on-command":[6,12,45,48,49,52,53,61,67],"query-features":[0,1,2,3,4,8,10,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,31,32,33,34,35,36,37,38,39,40,41,42,43,55,56,57,58,59,63,64,69,70,71,72,73,74,75,77,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100],"sql-commands":[5,7,11,13,30,44,46,47,50,51,54,60,62,65,66,68,76,78]}, + "cte-with-multi-children-operators": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15],"sql-commands":[0,1]}, + "current_database_catalog": {"fn-misc":[0]}, + "date": {"cast-matrix":[8,9],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99],"depends-on-command":[55,56,57,58,68,69],"fn-json":[76],"fn-url-xml-csv":[77],"nested-interval-types":[74],"sql-commands":[0]}, + "datetime-formatting": {"datetime":[31,32,33],"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0]}, + "datetime-formatting-invalid": {"datetime":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36]}, + "datetime-formatting-legacy": {"datetime":[31,32,33],"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0]}, + "datetime-legacy": {"cast-matrix":[8,9,106,107,108],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99,102,109,110,111,112,113,114,115,116,117,118,119,120,121,122,125,126,127,128,129,130,131,134,136,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,161,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,213,214,215,216,217,219,220,221,222,225,226,227,228,231,232,233,234,237,238,239,240],"depends-on-command":[55,56,57,58,68,69,163,165,166,211,212],"fn-json":[76,223],"fn-url-xml-csv":[77,224],"nested-interval-types":[74,218],"sql-commands":[0,162,164,210],"time-geo-types":[123,124,132,133,135,137]}, + "datetime-parsing": {"datetime":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]}, + "datetime-parsing-invalid": {"cast-matrix":[27],"datetime":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,23,24,25,26],"fn-url-xml-csv":[18]}, + "datetime-parsing-legacy": {"datetime":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]}, + "datetime-special": {"datetime":[1,2,3],"output-names":[0]}, + "decimalArithmeticOperations": {"depends-on-command":[1,2,3,6,7,30,31],"output-names":[13,21,37],"sql-commands":[0,4,5,29,54]}, + "describe": {"depends-on-command":[42,43,44,45,46,47],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67]}, + "describe-part-after-analyze": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]}, + "describe-query": {"depends-on-command":[15],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,16,17,18]}, + "describe-table-after-alter-table": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11]}, + "double-quoted-identifiers": {"nested-interval-types":[20,24],"query-features":[16],"sql-commands":[10,11,12,18,19,22,23]}, + "double-quoted-identifiers-enabled": {"depends-on-command":[27],"nested-interval-types":[24],"query-features":[7,16],"sql-commands":[1,2,3,10,11,12,19,22,23,25,26,28,29]}, + "except": {"depends-on-command":[2,3,4,5,6,7,8,10,11],"sql-commands":[0,1,9,12,13,14]}, + "except-all": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],"sql-commands":[0,1,2,3,23,24,25,26]}, + "execute-immediate": {"depends-on-command":[19,29,32,34,37,39,42,44],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,20,21,22,23,24,25,26,27,28,30,31,33,35,36,38,40,41,43,45,46,47,48,49,50,51,52,55,56,57,58,59,60,62,63,64,65,66,67,68,69,70,71,72,73,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117]}, + "explain": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,18,19,20,21,22,29],"query-features":[17],"sql-commands":[0,1,2,3,4,5,23,24,25,26,27,28,30]}, + "explain-aqe": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,18,19,20,21,22,29],"query-features":[17],"sql-commands":[0,1,2,3,4,5,23,24,25,26,27,28,30]}, + "explain-cbo": {"depends-on-command":[4],"sql-commands":[0,1,2,3,5,6]}, + "extract": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,127],"nested-interval-types":[102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,128],"sql-commands":[0]}, + "extract-value-nulltype-single-pass": {"nested-interval-types":[0]}, + "extract-value-resolution-edge-cases": {"depends-on-command":[1,2],"nested-interval-types":[5,6,7],"query-features":[3],"sql-commands":[0,4]}, + "generators": {"depends-on-command":[1,2,3,10,11,12,19,20,21,28,29,30,39,40,46,47],"fn-json":[51,52,53,54,55],"generators":[4,5,7,8,13,14,16,17,22,23,25,26,31,32,34,35,41,42,48,49,56,57,58,59,60],"nested-interval-types":[6,9,15,18,24,27,33,36,37,38,43,44,45,50],"sql-commands":[0]}, + "generators-resolution-edge-cases": {"fn-array":[24,25,26,28],"generators":[0,1,2,3,4,5,10,11,12,13,27,29,32,33,34,35,44,45,46,47,48,49],"query-features":[6,7,8,9,14,15,16,17,18,19,20,21,22,23,36,37,38,39,40,41,42,43,50,51,52,53],"window":[30,31]}, + "group-analytics": {"depends-on-command":[1,2,3,4,6,7,9,10,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51],"sql-commands":[0,5]}, + "group-by": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,18,20,34,35,36,37,38,39,40,41,48,49,50,51,52,53,54,55,56,57,58,60,61,81,96,97,98,99,100,101],"fn-aggregate":[42,43,44,45,46,47],"query-features":[16,24,25,26,27,29,30,31,59,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,82,83,84,85,86,87,88,89,90,91,92,93,94,95],"sql-commands":[0,1,17,19,28,32,33,102]}, + "group-by-alias": {"analyzer-bugs":[11],"depends-on-command":[1,2,3,4,5,6,8,9,10,12,13,14,15,16,17,18,20,22,24,34],"query-features":[21,23,26,27,28,29,35],"sql-commands":[0,30]}, + "group-by-all": {"depends-on-command":[1,2,3,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,28],"query-features":[4,27],"sql-commands":[0]}, + "group-by-all-duckdb": {"depends-on-command":[1,2,3,4,5,6],"query-features":[7,8],"sql-commands":[0]}, + "group-by-all-mosha": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10],"sql-commands":[0]}, + "group-by-filter": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,69,70,71,72,73,74,75,76,77,78,79,80],"query-features":[68],"sql-commands":[0,1,2,3]}, + "group-by-ordinal": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,17,18,19,20,21,22,23,24,25,26,27,28,29,30,32,34],"query-features":[31],"sql-commands":[0,33]}, + "grouping_set": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,16,17,19,20,21,23,25,26,27,30,31,32,33,34,35,37,38,39,41,42,43,44,45],"query-features":[18,22,24,28,29],"sql-commands":[0,36,40]}, + "grouping_set_grand_total_disabled": {"query-features":[0,1,2,3,4,5,6,7]}, + "having": {"conditional-physical":[48],"depends-on-command":[1,2,3,4,14,15,16,17,18,19,20,21,22,23,28,29,30,31,32],"query-features":[5,6,7,8,9,10,11,12,13,24,25,26,27,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,49],"sql-commands":[0]}, + "having-and-order-by-recursive-type-name-resolution": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44]}, + "higher-order-functions": {"depends-on-command":[3,4,5,6,7,9,11,12,13,14,16,17,18,20,22,26,27,28,29,30,31],"hof":[1,2,23,24,34,35,36,38,39,40,42,43,44,46,47,48,50,51,52,54,55,56,58,59,60,62,63,64,66,67,68,70,71,72,74,75,76,78,79,80,82],"nested-interval-types":[8,10,15,19,21,37,41,45,49,53,57,61,65,69,73,77,81],"query-features":[32,33],"sql-commands":[0,25]}, + "hll": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17],"fn-aggregate":[31,32,33],"query-features":[18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0,1,2,3,4,5,6,7,34,35,36]}, + "identifier-clause": {"depends-on-command":[1,2,3,4,5,6,7,15,16,17,18,22,23,24,40,52,80,83,84,85,86,87,88,90,91,92,93,94,102,103,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,134,138,140,142,145,150,151,177,180,183,215,216,220,221],"sql-commands":[0,8,9,10,11,12,13,14,19,20,21,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,81,82,89,95,96,97,98,99,100,101,104,105,106,107,108,109,110,111,112,113,114,115,116,133,135,136,137,139,141,143,144,146,147,148,149,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,178,179,181,182,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,217,218,219,222,223,224,225,226,228,229,232,236]}, + "identifier-clause-legacy": {"depends-on-command":[1,2,3,4,5,6,7,15,16,17,18,22,23,24,40,52,80,83,84,85,86,87,88,90,91,92,93,94,102,103,117,118,119,122,125,177,183],"sql-commands":[0,8,9,10,11,12,13,14,19,20,21,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,81,82,89,95,96,97,98,99,100,101,104,105,106,107,108,109,110,111,112,113,114,115,116,135,146,147,149,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,168,169,170,171,172,173,174,175,178,181,184,185,186,187,188,189,190,191,192,193,195,196,197,202,203,208,209,211,212,213,214,217,218,219,222,223,226,228,229,232,236]}, + "ilike": {"fn-string":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]}, + "ilike-all": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12],"sql-commands":[0]}, + "ilike-any": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12],"sql-commands":[0]}, + "inline-table": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,14,16,17,18,19,20,21,22,23,24,25,26]}, + "inner-join": {"depends-on-command":[6],"sql-commands":[0,1,2,3,4,5]}, + "intersect-all": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,17,18,21,22],"sql-commands":[0,1,16,19,20,23,24,25]}, + "interval": {"datetime":[0,4,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86],"depends-on-command":[160,161,162,163],"nested-interval-types":[2,3,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,39,40,42,43,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,87,88,89,90,91,92,93,94,96,97,98,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,121,122,123,124,125,126,127,128,129,130,131,148,150,151,152,153,154,155,156,157,158,164,165,166,167,168,169,170,171,172,173,174,175,176,177,179,189,190,191,192,202,203,204,205,206,209,210,211,212,215,216,217,218,219,220,221,222,223,224,225,226,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285],"query-features":[184,185,186],"sql-commands":[159]}, + "join-empty-relation": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],"sql-commands":[0,1,2]}, + "join-lateral": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,19,20,21,22,23,25,26,27,28,29,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,105,106,107,108,110,111,112,113,114,115,116,118,119,120,121,122,125,126,127,128,129,130,131,133,134,135,136,138,139,140,141,142,143,144,145,146,147,148],"query-features":[24,30,104,109,124,149,150,151,152,153],"sql-commands":[0,1,2,3,117,123,132,137,154,155,156,157]}, + "join-nearest-by": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,22,25],"sql-commands":[0,1,21,23,24,26,27,28]}, + "join-resolution-edge-cases": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12],"sql-commands":[0,1,13,14]}, + "json-functions": {"depends-on-command":[20,46],"fn-json":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,21,22,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,73,74,75,76,77,78,79,80,94,95,96,97,98,99,100,101,102,103,104,105],"sql-commands":[19,23,45,72],"time-geo-types":[81,82,83,84,85,86,87,88,89,90,91,92,93]}, + "keywords": {"query-features":[0,1]}, + "keywords-enforced": {"query-features":[0,1]}, + "kllquantiles": {"depends-on-command":[12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,68,69,70,71,72,73,74,75,76,77,78,82,83,84,85,92,93,94,95,96,97,98,99,100,101],"fn-aggregate":[36,37,67,79,80,81,86,87,88,89,90,91],"query-features":[33,34,35],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,102,103,104,105,106,107]}, + "like-all": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12],"sql-commands":[0]}, + "like-any": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12],"sql-commands":[0]}, + "limit": {"analyzer-bugs":[9],"nested-interval-types":[1,2],"parser-tail":[6],"query-features":[12]}, + "linear-regression": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"sql-commands":[0]}, + "listagg": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,21,41,42,43,44,45,46,47],"query-features":[18,19,20,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,48,49,50],"sql-commands":[0,1]}, + "listagg-collations": {"parser-pipe-collate":[0,1,3,4,5,6,7,8,10,12,14],"query-features":[2,9,11,13]}, + "literals": {"datetime":[36,45,52],"fn-array":[48],"fn-map":[47],"fn-struct":[49],"legacy-configs":[59,60],"nested-interval-types":[46],"output-names":[20,21,26,39,43],"sql-commands":[58]}, + "map": {"fn-array":[0],"fn-map":[2,3,4,5,6,7,8,9],"nested-interval-types":[1]}, + "mask-functions": {"fn-string":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,29,30,31,32,33,34,35,36,37,38,39,40,41,42,55,56],"query-features":[15,16,17,18,19,20,21,22,23,24,25,26,27,28,43,44,45,46,47,48,49,50,51,52,53,54]}, + "math": {"fn-string":[56,57,58,59,60,61,62,63,64,65]}, + "max-min-by-k": {"depends-on-command":[1,2,3,4,5,6,8,9,11,12,14,15,17,18,20,21,22,23,24,25],"sql-commands":[0,7,10,13,16,19,26,27,28,29,30,31]}, + "metadata_column_resolution": {"depends-on-command":[5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53],"sql-commands":[0,1,2,3,4,54,55,56,57]}, + "misc-functions": {"datetime":[4],"depends-on-command":[15],"fn-misc":[0,1,2,3,5,6,7,8,9,10,11,12,14,16,17,18,19,20],"query-features":[25],"sql-commands":[13,21,24]}, + "mode": {"depends-on-command":[1,2,3,14,15,16,17,18,19,20,21,22,23,24,26,27],"query-features":[4,5,6,7,8,9,10,11,12,13],"sql-commands":[0,25]}, + "name-precedence-in-order-by-and-having-with-conflicting-attributes": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"query-features":[18,19,39,40],"sql-commands":[0,1,44,45]}, + "named-function-arguments": {"depends-on-command":[5,6,7,26],"fn-string":[33],"query-features":[0,1,2,3,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,27,28,29,30,31,32],"sql-commands":[4,25]}, + "natural-join": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"query-features":[31,32,33],"sql-commands":[0,1,2,3]}, + "non-excludable-rule": {"query-features":[1,3,5],"sql-commands":[0,2,4]}, + "nonansi/array": {"depends-on-command":[1,2,3,5,6,7,8,11],"fn-array":[9,10,12,13,14,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,59,60,63,64,65,66,67,68,69,70,71,74,76,77,78,79,80,83,85,86,87],"fn-string":[15,16,17,18,19,20,21],"nested-interval-types":[22,23,52,72,73,75,81,82,84],"query-features":[62],"sql-commands":[0,4,58,61]}, + "nonansi/cast": {"cast-matrix":[58,59,60,66,67,70,71,130,131],"fn-string":[28,29,30,31,32,33,34,35,36,124,125],"nested-interval-types":[39,40,41,43,44,72,73,74,75,76,77,78,79,80,81,82,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,126,127,132,133,134,135,143],"query-features":[83,87],"sql-commands":[37,38],"time-geo-types":[104,105,106,107,108,109,110,111,112,113,114,115,116,136,137,138,139,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163]}, + "nonansi/conditional-functions": {"conditional-physical":[5,6,8,9,13,14,15,16],"depends-on-command":[1,2,3,4,7,10],"sql-commands":[0,17]}, + "nonansi/date": {"cast-matrix":[8,9],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99],"datetime-bugs":[37,50],"depends-on-command":[55,56,57,58,68,69],"fn-json":[76],"fn-url-xml-csv":[77],"nested-interval-types":[74],"sql-commands":[0]}, + "nonansi/datetime-parsing-invalid": {"cast-matrix":[27],"datetime":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,23,24,25,26],"fn-url-xml-csv":[18]}, + "nonansi/datetime-special": {"datetime":[1,2,3],"output-names":[0]}, + "nonansi/decimalArithmeticOperations": {"depends-on-command":[1,2,3,6,7,30,31],"output-names":[13,21,37,45],"sql-commands":[0,4,5,29,54]}, + "nonansi/double-quoted-identifiers": {"nested-interval-types":[20,24],"query-features":[16],"sql-commands":[10,11,12,18,19,22,23]}, + "nonansi/higher-order-functions": {"depends-on-command":[3,4,5,6,7,9,11,12,13,14,16,17,18,20,22,26,27,28,29,30,31],"hof":[1,2,23,24,34,35,36,38,39,40,42,43,44,46,47,48,50,51,52,54,55,56,58,59,60,62,63,64,66,67,68,70,71,72,74,75,76,78,79,80,82],"nested-interval-types":[8,10,15,19,21,37,41,45,49,53,57,61,65,69,73,77,81],"query-features":[32,33],"sql-commands":[0,25]}, + "nonansi/interval": {"datetime":[0,4,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86],"depends-on-command":[160,161,162,163],"nested-interval-types":[2,3,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,39,40,42,43,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,87,88,89,90,91,92,93,94,96,97,98,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,121,122,123,124,125,126,127,128,129,130,131,148,150,151,152,153,154,155,156,157,158,164,165,166,167,168,169,170,171,172,173,174,175,176,177,179,189,190,191,192,202,203,204,205,206,209,210,211,212,215,216,217,218,219,220,221,222,223,224,225,226,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285],"query-features":[184,185,186],"sql-commands":[159]}, + "nonansi/keywords": {"query-features":[0,1]}, + "nonansi/literals": {"datetime":[36,45,52],"fn-array":[48],"fn-map":[47],"fn-struct":[49],"legacy-configs":[59,60],"nested-interval-types":[46],"output-names":[20,21,26,39,43],"sql-commands":[58]}, + "nonansi/map": {"fn-array":[0],"fn-map":[2,3,4,5,6,7,8,9],"nested-interval-types":[1]}, + "nonansi/math": {"fn-string":[56,57,58,59,60,61,62,63,64,65]}, + "nonansi/parse-schema-string": {"fn-json":[2,3],"fn-url-xml-csv":[0,1]}, + "nonansi/string-functions": {"depends-on-command":[218],"fn-misc":[5],"fn-number-format":[173,174,175,176,177,178,179,180,181],"fn-regex":[13,14,15,16,17,18,19,20,21,22,23,24,25,26],"fn-string":[0,1,6,7,8,9,10,11,12,27,28,29,30,31,32,33,34,35,36,60,61,62,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,98,101,103,106,109,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,130,133,136,139,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252],"output-names":[4,38,39,41,42,43,44,45,47,48,51,52,53,54,55,56,57,58,63,64],"query-features":[37,99,102,104,107,110,128,131,134,137,140],"sql-commands":[97,100,105,108,129,132,135,138,217,219]}, + "nonansi/timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62,108],"time-geo-types":[21,22,30,31,33,35]}, + "nonansi/try_aggregates": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31]}, + "nonansi/try_arithmetic": {"cast-matrix":[2,32,43,58],"coercion":[3,33,44,59],"datetime":[11,12,17,18],"nested-interval-types":[13,14,15,16,19,20,21,22,23,24,25,35,36,37,38,39,40,52,53,54,55,67,68,69,70,71,72],"query-features":[10,34,51,66]}, + "nonansi/try_datetime_functions": {"datetime":[0,1,2,3,4,5]}, + "nonansi/try_element_at": {"fn-array":[0,1,2,3,4,5,6,7]}, + "null-handling": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29],"sql-commands":[0,1,2,3,4,5,6,7,30]}, + "null-propagation": {"query-features":[0,1,2,3]}, + "operators": {"fn-string":[57,60,65,66,67,68,69,70,71,72,73,74,75,76],"output-names":[32,33,34,35,36,37,38,39,40,41,42,43,46,48,50,51,52,53,54,55,62]}, + "order-by": {"depends-on-command":[1,2,3,4,7,8,9,10,11,15,16,17,18,19,20,21,22,23,24,25,26,27],"query-features":[5,6,12,13,28,29,30,31,32,33,34,35],"sql-commands":[0,36],"variant-type":[14]}, + "order-by-alias": {"depends-on-command":[1,2,3,4,5,6,7,9,10,11,12],"query-features":[14,15,16,17],"sql-commands":[0]}, + "order-by-all": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14],"query-features":[15,16,17],"sql-commands":[0]}, + "order-by-and-having-on-top-of-aggregate-with-join": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145],"sql-commands":[0,1,146,147]}, + "order-by-nulls-ordering": {"depends-on-command":[2,3,4,5,6,7,8,9,13,14,15],"sql-commands":[0,1,10,11,12,16]}, + "order-by-ordinal": {"depends-on-command":[1,2,3,4,5,6,7,8,10,11,12,13,14,15,16,18,19,20,21,22,23,24,26,27],"sql-commands":[0,9,17,25]}, + "outer-join": {"depends-on-command":[2,5],"sql-commands":[0,1,3,4]}, + "parameterless-function-name-precedence": {"depends-on-command":[2,3,5,7,13],"fn-misc":[9,10],"sql-commands":[0,1,6,8,14,15]}, + "parameterless-function-name-precedence-legacy": {"depends-on-command":[2,3,5,7,13],"fn-misc":[9,10],"sql-commands":[0,1,6,8,14,15]}, + "parse-query-correctness": {"depends-on-command":[1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,38,40,42,46,48,50,52,54,56,58,60,62,64],"sql-commands":[0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,37,39,41,43,44,45,47,49,51,53,55,65]}, + "parse-query-correctness-old-behavior": {"depends-on-command":[1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,38,40,42,46,48,50,52,54,56,58,60,62,64],"sql-commands":[0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,37,39,41,43,44,45,47,49,51,53,55,65]}, + "parse-schema-string": {"fn-json":[2,3],"fn-url-xml-csv":[0,1]}, + "percentiles": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,38,39,40,41,42,43,44],"query-features":[45,46,47,48,50,51],"sql-commands":[0,1,35,49,52]}, + "pipe-operators": {"depends-on-command":[25,26,27,28,29,30,31,32,33,34,37,38,39,41,42,43,44,45,47,48,49,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,88,89,92,93,94,95,96,99,100,101,103,105,106,107,110,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,184,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,205,206,207,208,209,210,211,212,214,215,216,217,218,219,220,233,234,235,238,241,242,244,245,246,247,248,250,251,252,254,256,257,258,259,260,261,262,263,264,265,266,267,268,269,277,281,282,283,284,285,287,288,290,292,296,300,301,302,303,304,305,307,308,310,311,312,313],"parser-pipe-collate":[35,40,46,50,90,91,97,98,102,104,166,204,221,222,223,224,225,226,227,228,229,230,231,232,236,237,239,240,243,255,270,271,272,273,274,275,276,278,279,280,286,298,306,309],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,289,291,293,294,295,299,314,315,316]}, + "pivot": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"sql-commands":[0,1,2]}, + "postgreSQL/aggregates_part1": {"depends-on-command":[45,46,47,48],"fn-aggregate":[9,10,11,12,13,14,15,16,17,18,35,36,37,38,39,40,41,42,43],"query-features":[19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"sql-commands":[44,49],"subqueries":[54,55]}, + "postgreSQL/aggregates_part2": {"depends-on-command":[2,3,4,5,6,7,8,12,13,14,15],"generators":[27],"sql-commands":[0,1,11]}, + "postgreSQL/aggregates_part3": {"query-features":[1,2,4],"subqueries":[3]}, + "postgreSQL/aggregates_part4": {"fn-aggregate":[0,1,2,3]}, + "postgreSQL/boolean": {"cast-matrix":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39],"depends-on-command":[44,45,46,47,49,56,57,58,59,60,61,62,63,64,65,66,67,68,73,76,77,78,79,80,81,82,83,84,85,86,87],"sql-commands":[40,41,42,43,48,50,51,52,53,54,55,69,70,71,72,74,75,88,89,90,91]}, + "postgreSQL/case": {"depends-on-command":[20,22,23,24,25,26,27,28,29,30,31],"fn-string":[17],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,33,34],"test-udfs":[32]}, + "postgreSQL/create_view": {"depends-on-command":[11,13,83,84],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,12,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194]}, + "postgreSQL/date": {"datetime":[48,49,50,51,52,53,54,55,56,57,58],"depends-on-command":[16,17,18,46,47],"output-names":[44,45],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,59]}, + "postgreSQL/float4": {"cast-matrix":[6,7,8,9,10,11,12,13,14,15,16,17,30,31,32,33,34,35,36,37,38,39,40,41],"depends-on-command":[18,19,20,21,22,23,24,25,26,27,28,29],"sql-commands":[0,1,2,3,4,5,42]}, + "postgreSQL/float8": {"cast-matrix":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,38,39,40,41,42,43,44,45,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,82,83,84,85,86,87,88,89,90,91,92,93],"depends-on-command":[22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,46,47,49,50,81],"sql-commands":[0,1,2,3,4,5,48,75,76,77,78,79,80,94]}, + "postgreSQL/groupingsets": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17,18,19,20,25,28,29,35,36,37,38,39,40,41,42,43,44,45,46,47],"grouping-sets":[21,22,23,27,30,31,32,33,34],"query-features":[48,49],"sql-commands":[0,1,2,3,4,5,6,7,24,26,50,51,52,53,54]}, + "postgreSQL/insert": {"depends-on-command":[5,7],"sql-commands":[0,1,2,3,4,6,8]}, + "postgreSQL/int2": {"cast-matrix":[29,30,31],"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28],"query-features":[32,33],"sql-commands":[0,1,2,3,4,5,34]}, + "postgreSQL/int4": {"cast-matrix":[39,40,41,42,46,47,48,49],"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"query-features":[50,51],"sql-commands":[0,1,2,3,4,5,52]}, + "postgreSQL/int8": {"cast-matrix":[62,63,64,69,71,72,77,78,79,80,81,82,83,84,85,86,87],"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,65,66,67,68,70,73],"query-features":[74,75,76,88,89],"sql-commands":[0,1,2,3,4,5,90]}, + "postgreSQL/interval": {"nested-interval-types":[0,1,2,3,4,5,6,7,8,9,10,11,14,17]}, + "postgreSQL/join": {"conditional-physical":[134,135],"depends-on-command":[28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,65,66,67,68,69,70,71,72,73,74,75,76,79,80,81,82,83,84,85,86,87,88,89,91,92,93,94,95,96,105,106,110,113,116,120,122,126,127,128,129,133,136,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,160,161,162,163,166,167,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,196],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,55,56,57,58,59,60,61,62,63,64,77,78,98,99,100,101,102,103,104,108,109,111,112,114,115,117,118,119,121,124,125,130,131,132,137,138,139,158,159,164,165,168,191,192,193,194,195,197,198]}, + "postgreSQL/limit": {"depends-on-command":[9,10],"fn-string":[12],"query-features":[3,4,5,6,7],"sql-commands":[8,11]}, + "postgreSQL/numeric": {"cast-matrix":[507,508,509,510,511,512],"depends-on-command":[460,463,466,469,472,475,478,481,484,487,490,493,496,497,505,521,533,538,539,540,541,542,558],"fn-number-format":[543,544,545,546,547,548,549,550,551],"fn-string":[523,524,525,526,527,528,529,530,534,535,536],"output-names":[561,563,564,565,569,570,571,572,573,574,575,579,585,586,587,588,589,590,591,592],"query-features":[576,577,578,593,594],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,461,462,464,465,467,468,470,471,473,474,476,477,479,480,482,483,485,486,488,489,491,492,494,495,498,499,500,501,502,503,504,506,513,514,515,516,517,518,519,520,522,531,532,537,552,553,554,555,556,557,595,596,597,598,599,600,601,602,603,604,605]}, + "postgreSQL/select": {"depends-on-command":[9,10,11,18,20,21,22,23,24,25,26,27,28,29,30,31,32],"query-features":[16,17,34,35],"sql-commands":[0,1,12,19,36]}, + "postgreSQL/select_distinct": {"depends-on-command":[1,2,3,4,7,8,9,10],"sql-commands":[0,6]}, + "postgreSQL/select_having": {"depends-on-command":[11,12,13,14,15,16,17,18,19,20],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,21]}, + "postgreSQL/select_implicit": {"depends-on-command":[11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,37]}, + "postgreSQL/strings": {"cast-matrix":[2,3,4,5,6,7,70,86,87,88,89,90,91,92,93,94,95,96,97,98,99,119,120,121,122],"depends-on-command":[76,77],"fn-string":[14,15,16,17,18,19,79,80,84,85,100,111,112,113,114,115,116,117,118],"output-names":[102,104,107,109],"sql-commands":[71,72,73,74,75,123]}, + "postgreSQL/text": {"cast-matrix":[0,1,7],"datetime":[11],"depends-on-command":[5],"fn-array":[17],"fn-string":[12,13,14,15,16,20,21,22,23,26,27,28,31,32,33,34,35,36,37,38,39,40],"query-features":[18],"sql-commands":[2,3,4,19,41]}, + "postgreSQL/timestamp": {"datetime":[25,28],"depends-on-command":[8,9,10,17,18,19,20,21,22,23,24,26,27],"sql-commands":[0,1,2,3,4,5,6,7,11,12,13,14,15,16,29]}, + "postgreSQL/union": {"cast-matrix":[13,15,17,68],"depends-on-command":[20,21,22,23,24,25,26,27,28,29,30,31,32,41,42,43,44,45,46,47,48,49,50,51,52,69,70,71],"query-features":[53,54,55,56,57,58,59,60,61,62,63,64,67],"sql-commands":[0,1,2]}, + "postgreSQL/window_part1": {"depends-on-command":[27,39],"sql-commands":[0,26,38,40,41,42],"window":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,28,29,30,31,32,33,34,35,36,37]}, + "postgreSQL/window_part2": {"depends-on-command":[17,18,19,20,21,22,23,24,25,26,27,28],"query-features":[9,10,11,12,13,14],"sql-commands":[0,1,15,16,29,30],"window":[2,3,4,5,6,7,8]}, + "postgreSQL/window_part3": {"depends-on-command":[9,12,13,14,15,17,18,19,21,22,24],"sql-commands":[0,1,2,3,4,10,11,27,28,29],"window":[5,6,7,8,16,25,26]}, + "postgreSQL/window_part4": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38]}, + "postgreSQL/with": {"depends-on-command":[5,7,12,23,24,25,26,32,34,38,39,40,43,44,45,46,47,59,60,61,68,69,70,71,72,73,81,86,87,88,89,92,93,97,99,100],"fn-string":[1],"query-features":[2,3,8,9,10,13,28,35,51,52,53,54,55,56,62,63,64,65,66,67,75,78,79],"sql-commands":[4,6,14,15,16,17,18,19,20,21,22,27,29,31,33,36,37,41,42,48,49,50,57,58,80,82,83,84,85,90,91,94,95,98,101,102,103,104,105,106,107,108,109,110]}, + "pred-pushdown": {"depends-on-command":[2,3],"sql-commands":[0,1]}, + "predicate-functions": {"datetime":[30,31,37,38,44,45,51,52,53,54,55,56,57,80,86],"fn-string":[81,87],"sql-commands":[88,94]}, + "qualify": {"depends-on-command":[1,2,4,5,6,7,8],"sql-commands":[0,3]}, + "query_regex_column": {"depends-on-command":[3,4,5,6,7,8,10,11,12,13,14,15,16,17,18,19,20,21,24,25,26,27,28,29,30,31,32,33],"sql-commands":[0,1,2,9,22,23]}, + "random": {"fn-string":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,61,62,63,64,65,66,67,70,71],"query-features":[25,41,42,60,68,69,72,73]}, + "regexp-functions": {"fn-regex":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67],"query-features":[31,68]}, + "replacing-missing-expression-with-alias": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]}, + "runtime-replaceable-edge-cases": {"fn-url-xml-csv":[0]}, + "scripting/randomly_generated_scripts": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124]}, + "selectExcept": {"depends-on-command":[2,3,4,5,6,7,8,9,10,12,14,15,16,17,18,21,22,23,24,27,28,29,30,31,32,33,34,35,37,38,39,40,41],"query-features":[11,36],"sql-commands":[0,1,13,25,26]}, + "session-variable-precedence": {"depends-on-command":[3,4,5,6],"sql-commands":[0,1,2,7,8,9]}, + "show-create-table": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]}, + "show-tables": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,15,17,18,19,20,21,22,23,24,25,26]}, + "show-tblproperties": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12]}, + "show-views": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]}, + "show_columns": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]}, + "sql-compatibility-functions": {"cast-matrix":[8,9,10,11],"conditional-physical":[0,1,2,3,4,5,6,7],"depends-on-command":[13],"query-features":[14],"sql-commands":[12]}, + "sql-on-files": {"depends-on-command":[4,9,14,19],"files":[2,7,12,17],"object-stores":[22],"sql-commands":[0,1,5,6,10,11,15,16,20,21]}, + "sql-path": {"depends-on-command":[38,42,47,49,64,66,81,82,87,103,104,108,113],"fn-misc":[0,2,4,6,9,11,14,18,21,23,26,27,125,131,137],"sql-commands":[1,3,5,7,8,10,12,13,15,16,17,19,20,22,24,25,28,29,30,31,32,33,34,35,36,37,39,40,41,43,44,45,46,48,50,51,53,54,55,56,57,58,59,60,61,62,63,65,67,69,70,71,72,73,74,75,76,77,78,79,80,83,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,105,106,107,109,110,111,112,114,115,116,117,118,119,120,121,122,123,124,126,127,128,129,130,132,133,134,135,136,138]}, + "sql-session-variables": {"depends-on-command":[4,6,10,12,15,21,32,34,36,38,40,42,44,46,60,63,79,81,83,85,87,89,91,93,104,106,108,110,112,114,120,127,129,134,144,148,166,168,170,172,174,189,194,197,200,203,206,209,212,234,235,236,237,241,242,243,244,245,246,247,248,250,251,252,254,264],"sql-commands":[0,1,2,3,5,7,8,9,11,13,14,16,18,19,20,22,24,25,26,29,30,31,33,35,37,39,41,43,45,47,48,49,50,51,52,53,54,55,56,57,58,59,61,62,64,66,67,68,69,70,75,76,77,78,80,82,84,86,88,90,92,94,95,96,97,98,99,100,101,102,103,105,107,109,111,113,115,116,117,118,119,121,122,123,124,125,126,128,130,131,132,133,135,136,137,138,139,140,141,142,143,145,146,147,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,167,169,171,173,175,176,177,178,179,180,181,182,183,184,185,186,187,188,190,191,192,193,195,196,198,199,201,202,204,205,207,208,210,211,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,238,239,240,253,255,256,257,258,259,260,261,262,263,265]}, + "sql-udf": {"depends-on-command":[1,2,4,5,7,9,11,13,17,19,21,23,25,29,30,31,35,39,41,43,44,54,56,66,68,70,72,74,76,78,79,80,82,83,84,86,87,88,90,91,92,94,95,96,98,99,100,102,103,104,106,107,108,111,112,114,115,117,119,120,121,123,124,126,127,129,130,132,133,134,136,137,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,205,206,207,209,211,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,295,296,297,298,299,300,303,304,305,306,307,309,310,312,314,315,317,319,324,326,330,336,337,338,342,343,344,349,350,351,352,354,355,356,357,406,407,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428],"sql-commands":[0,3,6,8,10,12,14,15,16,18,20,22,24,26,27,28,32,33,34,36,37,38,40,42,45,46,47,48,49,50,51,53,55,57,58,60,61,62,63,64,65,67,69,71,73,75,77,81,85,89,93,97,101,105,109,110,113,118,122,125,128,131,135,138,139,141,143,145,147,149,151,153,155,157,159,161,163,165,167,169,171,173,175,177,179,181,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,208,210,212,213,214,215,216,217,218,219,220,221,222,223,224,225,301,302,308,311,313,316,318,320,321,322,323,325,327,328,329,331,332,333,334,335,339,340,341,345,346,347,348,353,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,408,409,410,411,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569]}, + "sql-udf-name-precedence": {"depends-on-command":[2,4,6,8,10,14,16,18,20,23,25],"sql-commands":[0,1,3,5,7,9,11,13,15,17,19,21,22,24,26,27,28,29,30,31,32,33,34,35,36,37,38,39]}, + "sql-udf-name-precedence-legacy": {"depends-on-command":[2,4,6,8,10,12,14,16,18,20,23,25],"sql-commands":[0,1,3,5,7,9,11,13,15,17,19,21,22,24,26,27,28,29,30,31,32,33,34,35,36,37,38,39]}, + "st-functions": {"depends-on-command":[16,17,18,19,20,21,22,23,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,58,59,69,70,71,72,73,84,85,86,87,88,89,90,91,92,96,97,102,103,104,105],"sql-commands":[0,1,2,106],"time-geo-types":[3,4,5,6,7,8,9,10,11,12,13,14,15,24,25,26,27,28,29,30,31,32,33,34,53,54,55,56,57,60,61,62,63,64,65,66,67,68,74,75,76,77,78,79,80,81,82,83,93,94,95,98,99,100,101]}, + "string-functions": {"depends-on-command":[218],"fn-misc":[5],"fn-number-format":[173,174,175,176,177,178,179,180,181],"fn-regex":[13,14,15,16,17,18,19,20,21,22,23,24,25,26],"fn-string":[0,1,6,7,8,9,10,11,12,27,28,29,30,31,32,33,34,35,36,60,61,62,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,98,101,103,106,109,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,130,133,136,139,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252],"output-names":[4,38,39,41,42,43,44,45,47,48,51,52,53,54,55,56,57,58],"query-features":[37,99,102,104,107,110,128,131,134,137,140],"sql-commands":[97,100,105,108,129,132,135,138,217,219]}, + "struct": {"depends-on-command":[3,4,5,6,7,8],"nested-interval-types":[1,2,9,11,13],"query-features":[10,12],"sql-commands":[0]}, + "subexp-elimination": {"depends-on-command":[1,2,3,4,5,6,7,8],"sql-commands":[0,9]}, + "subquery/exists-subquery/exists-aggregate": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],"sql-commands":[0,1,2]}, + "subquery/exists-subquery/exists-basic": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12],"sql-commands":[0,1,2]}, + "subquery/exists-subquery/exists-count-bug": {"depends-on-command":[3,4,5,6,7,8,9,11,12,13,14,15,16],"sql-commands":[0,1,2,10,17]}, + "subquery/exists-subquery/exists-cte": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2]}, + "subquery/exists-subquery/exists-having": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2]}, + "subquery/exists-subquery/exists-in-join-condition": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48],"sql-commands":[0,1,2]}, + "subquery/exists-subquery/exists-joins-and-set-ops": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24],"sql-commands":[0,1,2]}, + "subquery/exists-subquery/exists-orderby-limit": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29],"sql-commands":[0,1,2]}, + "subquery/exists-subquery/exists-outside-filter": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14],"sql-commands":[0,1,2]}, + "subquery/exists-subquery/exists-within-and-or": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2]}, + "subquery/in-subquery/in-basic": {"depends-on-command":[3,4,5,6],"sql-commands":[0,1,2]}, + "subquery/in-subquery/in-count-bug": {"depends-on-command":[3,4,5,6,7,8,9,10,11,13,14,15,16,17,18,19],"sql-commands":[0,1,2,12,20]}, + "subquery/in-subquery/in-group-by": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26],"sql-commands":[0,1,2]}, + "subquery/in-subquery/in-having": {"depends-on-command":[3,4,5,6,7,8,9,10,11],"sql-commands":[0,1,2]}, + "subquery/in-subquery/in-joins": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0,1,2,3,4,5,31,32,33]}, + "subquery/in-subquery/in-limit": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36],"sql-commands":[0,1,2,35,37]}, + "subquery/in-subquery/in-multiple-columns": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2]}, + "subquery/in-subquery/in-null-semantics": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17,19,20,23,24,25,26,27,28],"sql-commands":[0,1,2,3,4,5,6,7,18,21,22,29,30,31,32,33]}, + "subquery/in-subquery/in-nullability": {"depends-on-command":[3,4,5,6,7,8],"sql-commands":[0,1,2]}, + "subquery/in-subquery/in-order-by": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],"sql-commands":[0,1,2]}, + "subquery/in-subquery/in-set-operations": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27],"sql-commands":[0,1,2]}, + "subquery/in-subquery/in-subquery-in-join-condition": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44],"sql-commands":[0,1,2]}, + "subquery/in-subquery/in-with-cte": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12],"sql-commands":[0,1,2]}, + "subquery/in-subquery/nested-not-in": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20],"sql-commands":[0,1,2,3,4,5]}, + "subquery/in-subquery/not-in-group-by": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2]}, + "subquery/in-subquery/not-in-joins": {"depends-on-command":[3,4,5,6,7,8],"sql-commands":[0,1,2]}, + "subquery/in-subquery/not-in-unit-tests-multi-column": {"depends-on-command":[2,3,4,5,6,7,8],"sql-commands":[0,1]}, + "subquery/in-subquery/not-in-unit-tests-multi-column-literal": {"depends-on-command":[1,2,3],"sql-commands":[0]}, + "subquery/in-subquery/not-in-unit-tests-single-column": {"depends-on-command":[2,3,4,5,6,7,8,9],"sql-commands":[0,1]}, + "subquery/in-subquery/not-in-unit-tests-single-column-literal": {"depends-on-command":[1,2,3,4],"sql-commands":[0]}, + "subquery/in-subquery/simple-in": {"depends-on-command":[3,4,5,6,7,8,9,12,13],"sql-commands":[0,1,2,10,11]}, + "subquery/negative-cases/invalid-correlation": {"depends-on-command":[3,4,5,6,7,9],"sql-commands":[0,1,2,8]}, + "subquery/negative-cases/subq-input-typecheck": {"depends-on-command":[5,6,7,8,9],"sql-commands":[0,1,2,3,4]}, + "subquery/resolution-edge-cases": {"depends-on-command":[3,4,5,6,7,8,9],"sql-commands":[0,1,2,10,11,12]}, + "subquery/scalar-subquery/nested-scalar-subquery-count-bug": {"depends-on-command":[5,6,7,8],"sql-commands":[0,1,2,3,4,9,10,11,12,13]}, + "subquery/scalar-subquery/scalar-subquery-count-bug": {"depends-on-command":[2,3,4,5,6,7,8,10,11,12,13,14,15,17,18,19],"sql-commands":[0,1,9,16,20]}, + "subquery/scalar-subquery/scalar-subquery-group-by": {"depends-on-command":[3,4,5,6,7,8,9,11,12,13,15,16,17,18,19,22],"sql-commands":[0,1,2,10,14,20,21,23]}, + "subquery/scalar-subquery/scalar-subquery-predicate": {"depends-on-command":[2,3,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59],"sql-commands":[0,1,4,5,6,39,40,41]}, + "subquery/scalar-subquery/scalar-subquery-select": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,19,20,21,22,23,24,25,31,32,33,34,35,36,37,38,42,43,44,45,46,47,48],"sql-commands":[0,1,2,17,18,27,28,29,30,39,41],"subqueries":[40]}, + "subquery/scalar-subquery/scalar-subquery-set-op": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58],"sql-commands":[0,1,2]}, + "subquery/subquery-nested-data": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,26],"sql-commands":[0,1,2,3,4,5,25,27,28,29]}, + "subquery/subquery-offset": {"depends-on-command":[6,7,8,9,10,11,12,13,16,17,18,19],"sql-commands":[0,1,2,3,4,5,14,15,20,21]}, + "table-aliases": {"depends-on-command":[1,2,12,13,14,15],"sql-commands":[0,10,11]}, + "table-valued-functions": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72]}, + "tablesample-negative": {"depends-on-command":[3,4],"sql-commands":[0,1,2,5]}, + "thetasketch": {"depends-on-command":[18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,80,81,82,83,84,85,86,87,88],"fn-aggregate":[101,102,103,104,105,106],"query-features":[67,68,69,70,71,72,73,74,75,76,77,78,79,89,90,91,92,93,94,95,96,97,98,99,100],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,107,108,109,110,111,112,113,114,115]}, + "time": {"cast-matrix":[145,146,147],"datetime":[4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,139,141,220,221,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,265,271,277,278,280,282],"depends-on-command":[5,142,143,144,222,223,224,225,226,227,228],"sql-commands":[0,1,2],"time-geo-types":[3,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,140,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,229,230,231,232,233,234,235,260,261,262,263,264,266,267,268,269,270,272,273,274,275,276,279,281,283]}, + "time-bucket": {"datetime":[13,27],"nested-interval-types":[1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,17,20,21,24,25,26,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64],"query-features":[18,19,22,23,65,66,67,69,70,71,72,73],"sql-commands":[0,68]}, + "timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62,108],"time-geo-types":[21,22,30,31,33,35]}, + "timestamp-ltz": {"datetime":[0,1,2,3,4,5,6,7,9,10,11,12,13,14,15,17,18,19,20,21],"time-geo-types":[8,16]}, + "timestamp-ntz": {"datetime":[0,1,2,3,4,5,6,7,9,10,11,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28],"depends-on-command":[32],"sql-commands":[29,30,31,33],"time-geo-types":[8,13,15]}, + "timestampNTZ/datetime-special": {"datetime":[1,2,3],"output-names":[0]}, + "timestampNTZ/datetime-special-ansi": {"datetime":[1,2,3],"output-names":[0]}, + "timestampNTZ/timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62,108],"time-geo-types":[21,22,30,31,33,35]}, + "timestampNTZ/timestamp-ansi": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62,108],"time-geo-types":[21,22,30,31,33,35]}, + "timezone": {"depends-on-command":[13],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,14]}, + "to_from_avro": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2,8,9]}, + "transform": {"depends-on-command":[3,4,5,6,7,8,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,39,41,43,44,45,49,50,51],"parser-tail":[9,38],"sql-commands":[0,1,2,11,12,37,40,42]}, + "try-string-functions": {"fn-string":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34]}, + "try_aggregates": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31]}, + "try_arithmetic": {"cast-matrix":[2,32,43,58],"datetime":[11,12,17,18],"nested-interval-types":[13,14,15,16,19,20,21,22,23,24,25,35,36,37,38,39,40,52,53,54,55,67,68,69,70,71,72],"query-features":[10,34,51,66]}, + "try_cast": {"cast-matrix":[22,23,24,27,28],"nested-interval-types":[20,21]}, + "try_datetime_functions": {"datetime":[0,1,2,3,4,5]}, + "try_element_at": {"fn-array":[0,1,2,3,4,5,6,7]}, + "try_reflect": {"fn-misc":[0,1,2,3,4,5,6,7,8,9,10,11]}, + "tuplesketch": {"depends-on-command":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,152,153,154,155,156,157,158,159,162,163,164,165,166,167,168,169,170,171,172,173,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,195,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,260,262,273,274,275,276,277,279,280,282,283,285,286,287,288,289,290],"fn-aggregate":[174,252,253,254,255,256,257,261,263,270,271,272,278,281,284],"query-features":[120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,160,161,190,191,192,193,194,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,258,259,264,265,266,267,268,269],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,291,292,293,294,295,296,297,298,299,300]}, + "type-coercion-edge-cases": {"depends-on-command":[1,2],"parser-tail":[3],"sql-commands":[0,4]}, + "typeCoercion/native/arrayJoin": {"datetime":[9],"fn-array":[0,1,2,3,4,5,6,7,8,10]}, + "typeCoercion/native/binaryComparison": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264],"sql-commands":[0]}, + "typeCoercion/native/booleanEquality": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96],"sql-commands":[0]}, + "typeCoercion/native/caseWhenCoercion": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144],"sql-commands":[0]}, + "typeCoercion/native/concat": {"depends-on-command":[12,13],"query-features":[0,1,2,4,5,6,8,9,10],"sql-commands":[3,7,11]}, + "typeCoercion/native/dateTimeOperations": {"nested-interval-types":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39],"sql-commands":[0]}, + "typeCoercion/native/decimalPrecision": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144],"sql-commands":[0]}, + "typeCoercion/native/division": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144],"sql-commands":[0]}, + "typeCoercion/native/elt": {"query-features":[0,1,3,5],"sql-commands":[2,4]}, + "typeCoercion/native/ifCoercion": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144],"sql-commands":[0]}, + "typeCoercion/native/implicitTypeCasts": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46],"sql-commands":[0]}, + "typeCoercion/native/inConversion": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288],"sql-commands":[0]}, + "typeCoercion/native/mapZipWith": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18],"sql-commands":[0]}, + "typeCoercion/native/mapconcat": {"depends-on-command":[1,2,3,4,5,6,7],"sql-commands":[0]}, + "typeCoercion/native/promoteStrings": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315],"sql-commands":[0]}, + "typeCoercion/native/stringCastAndExpressions": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,28,29,30,31],"fn-string":[27],"sql-commands":[0]}, + "typeCoercion/native/widenSetOperationTypes": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144],"sql-commands":[0]}, + "typeCoercion/native/windowFrameCoercion": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24],"sql-commands":[0]}, + "udaf/udaf": {"depends-on-command":[2,3,5],"sql-commands":[0,1,4,6,7]}, + "udaf/udaf-group-analytics": {"depends-on-command":[1,2,3,4,6,7,9,10,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38],"sql-commands":[0,5]}, + "udaf/udaf-group-by": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,18,20,21,22,23,27,28,29,30,31,32,33],"sql-commands":[0,17,19,26],"test-udfs":[13,24,25]}, + "udaf/udaf-group-by-ordinal": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,28],"sql-commands":[0,27],"test-udfs":[11,12]}, + "udaf/udaf-grouping-set": {"depends-on-command":[1,2,3,4,5,6,7,8,11,12,13,14],"sql-commands":[0]}, + "udf/postgreSQL/udf-aggregates_part1": {"depends-on-command":[44,45,46,47],"sql-commands":[43,48],"test-udfs":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,49,50,51,52,53,54,55]}, + "udf/postgreSQL/udf-aggregates_part2": {"depends-on-command":[2,3,4,8,9,10,11],"sql-commands":[0,1,7],"test-udfs":[12,13,14,15,16,17,18,19,20,21,22,23,24]}, + "udf/postgreSQL/udf-aggregates_part3": {"test-udfs":[0,1]}, + "udf/postgreSQL/udf-aggregates_part4": {"test-udfs":[0,1,2,3]}, + "udf/postgreSQL/udf-case": {"depends-on-command":[21,22,23,24,25,26,27,28,29,30],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,32,33],"test-udfs":[12,13,14,15,16,17,18,19,20,31]}, + "udf/postgreSQL/udf-join": {"depends-on-command":[28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,65,66,67,68,69,70,71,72,73,74,75,76,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,105,106,107,114,117,120,124,126,127,130,131,132,133,137,140,144,145,146,147,148,149,150,151,152,153,154,155,158,159,160,161,164,165,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,194],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,55,56,57,58,59,60,61,62,63,64,77,78,98,99,100,101,102,103,104,108,109,110,111,112,113,115,116,118,119,121,122,123,125,128,129,134,135,136,141,142,143,156,157,162,163,166,189,190,191,192,193,195,196],"test-udfs":[138,139]}, + "udf/postgreSQL/udf-select_having": {"depends-on-command":[11,12,13,14,15,16,17,18,19,20],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,21]}, + "udf/postgreSQL/udf-select_implicit": {"depends-on-command":[11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,37]}, + "udf/udf-count": {"depends-on-command":[1,2,3,4],"sql-commands":[0]}, + "udf/udf-cross-join": {"depends-on-command":[2,3,4,5,6,11,12],"sql-commands":[0,1,7,8,9,10]}, + "udf/udf-except": {"depends-on-command":[2,3,4,5,6,7,8],"sql-commands":[0,1]}, + "udf/udf-except-all": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],"sql-commands":[0,1,2,3,23,24,25,26]}, + "udf/udf-group-analytics": {"depends-on-command":[1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28],"sql-commands":[0,5]}, + "udf/udf-group-by": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,15,16,17,19,21,22,23,24,31,32,33,34,35,36,37,38,43,44,45,46,47,48,49,50,51],"sql-commands":[0,18,20,30],"test-udfs":[14,25,26,27,28,29,39,40,41,42]}, + "udf/udf-having": {"depends-on-command":[1,2,3],"sql-commands":[0],"test-udfs":[4]}, + "udf/udf-inline-table": {"test-udfs":[0,1,2,3,4,5,6,7,8,9,10,12,14,15,16]}, + "udf/udf-inner-join": {"depends-on-command":[6],"sql-commands":[0,1,2,3,4,5]}, + "udf/udf-intersect-all": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,17,18],"sql-commands":[0,1,16,19,20,21]}, + "udf/udf-join-empty-relation": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],"sql-commands":[0,1,2]}, + "udf/udf-natural-join": {"depends-on-command":[2,3,4,5],"sql-commands":[0,1]}, + "udf/udf-outer-join": {"depends-on-command":[2,6],"sql-commands":[0,1,3,4,5,7]}, + "udf/udf-pivot": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29],"sql-commands":[0,1,2]}, + "udf/udf-special-values": {"test-udfs":[0,1,2,3,4,5]}, + "udf/udf-udaf": {"depends-on-command":[2,3,5],"sql-commands":[0,1,4,6,7]}, + "udf/udf-union": {"depends-on-command":[2,3,8],"sql-commands":[0,1,5,6,7,11,12,13,14,15],"test-udfs":[4,9,10]}, + "udf/udf-window": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,17,18,19,20,21,22],"sql-commands":[0]}, + "udtf/udtf": {"depends-on-command":[9,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,30,31,32,33,34,35,36,37,38,39,40,41,42,59,60,68],"sql-commands":[0,1,2,3,71,72],"test-udfs":[4,5,6,7,8,11,12,54,56,57,58,63,64,65,66,67,69,70]}, + "union": {"depends-on-command":[3,4,9,13,14,15],"fn-array":[11],"fn-map":[10],"sql-commands":[0,1,2,6,7,8,12,16,17,18,19,20,21,22]}, + "union-per-child-output-deduplication": {"depends-on-command":[4,5,6,7,8,9,10,11],"sql-commands":[0,1,2,3,12,13]}, + "union-resolution-edge-cases": {"depends-on-command":[2,3,5,6,7,8,9],"sql-commands":[0,1,10,11]}, + "unpivot": {"depends-on-command":[1,2,3,5,6,7],"sql-commands":[0,4]}, + "url-functions": {"fn-url-xml-csv":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]}, + "using-join": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39],"query-features":[40,41],"sql-commands":[0,1]}, + "variant-field-extractions": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,33,34,35,36,37,38,39],"sql-commands":[0]}, + "variant/named-function-arguments": {"query-features":[0,1,2,3,4]}, + "vector-agg": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]}, + "vector-distance": {"fn-misc":[0,1,2,3,4,5,6,7,8,9,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41],"nested-interval-types":[11,12]}, + "vector-norm": {"fn-misc":[0,1,2,3,4,5,6,7,8,9,10,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45],"nested-interval-types":[11,12,13,14]}, + "view-conf": {"depends-on-command":[4,8],"sql-commands":[0,1,2,3,5,6,7,9,10]}, + "view-schema-binding": {"depends-on-command":[3,7,12,16,22,28],"sql-commands":[0,1,2,4,5,6,8,9,10,11,13,14,15,17,18,19,20,21,23,24,25,26,27,29,30,31]}, + "view-schema-binding-config": {"depends-on-command":[18,23,31,37,44,50,56,59,62,68,72,76],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,24,25,26,27,28,29,30,32,33,34,35,36,38,39,40,41,42,43,45,46,47,48,49,51,52,53,54,55,57,58,60,61,63,64,65,66,67,69,70,71,73,74,75,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101]}, + "view-schema-compensation": {"depends-on-command":[4,9,14,17,20,26,30,34,44,47],"sql-commands":[0,1,2,3,5,6,7,8,10,11,12,13,15,16,18,19,21,22,23,24,25,27,28,29,31,32,33,35,36,37,38,39,40,41,42,43,45,46,48,49]}, + "view-schema-evolution": {"depends-on-command":[4,9,14,20,24,30,35,40,46,50,54,64,70,76,83,86,96],"sql-commands":[0,1,2,3,5,6,7,8,10,11,12,13,15,16,17,18,19,21,22,23,25,26,27,28,29,31,32,33,34,36,37,38,39,41,42,43,44,45,47,48,49,51,52,53,55,56,57,58,59,60,61,62,63,65,66,67,68,69,71,72,73,74,75,77,78,79,80,81,82,84,85,87,88,89,90,91,92,93,94,95,97,98,99]}, + "view-schema-type-evolution": {"depends-on-command":[4,9,14,20,24,28,36,42,51,54],"sql-commands":[0,1,2,3,5,6,7,8,10,11,12,13,15,16,17,18,19,21,22,23,25,26,27,29,30,31,32,33,34,35,37,38,39,40,41,43,44,45,46,47,48,49,50,52,53,55,56,57]}, + "view-with-default-collation": {"depends-on-command":[2,5,11,12,18,19,25,26,29,30,31,32,37,38,39,40,41,42,46,47,49,56,57,58,61,64,70,71,77,78,84,85,88,89,90,91,96,97,98,99,100,101,105,106,108,115,116,117],"sql-commands":[0,1,3,4,6,7,8,9,10,13,14,15,16,17,20,21,22,23,24,27,28,33,34,35,36,43,44,45,48,50,51,52,53,54,55,59,60,62,63,65,66,67,68,69,72,73,74,75,76,79,80,81,82,83,86,87,92,93,94,95,102,103,104,107,109,110,111,112,113,114,118,119]}, + "window": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,26,27,28,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,49,50,51,52,53,54,55,56,57,58,59,61,62,63,64,65,66,67,68,69,70],"query-features":[29],"sql-commands":[0,1,2,60]}, + "window-with-aggregates": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]}, + "xml-functions": {"depends-on-command":[30],"fn-url-xml-csv":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,15,16,17,18,19,20,21,22,23,24,25,26,27,28,32,33,34,35,36,37,38,39,50,51,52,53,54,55],"sql-commands":[14,29,31],"time-geo-types":[40,41,42,43,44,45,46,47,48,49]} + } +} diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 6078fd209..65a793ed1 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -19,7 +19,7 @@ use xtask::layering; use xtask::policy::{self, DiffArgs}; use xtask::registry_coverage; -const USAGE: &str = "usage: cargo xtask "; +const USAGE: &str = "usage: cargo xtask "; fn main() -> ExitCode { let args: Vec = std::env::args().skip(1).collect(); From 29eff5fae3cc9659d672ac2c80c682837f98a395 Mon Sep 17 00:00:00 2001 From: techysneha14 <343708768+shehatathe@users.noreply.github.com> Date: Thu, 22 Oct 2026 20:28:28 +0200 Subject: [PATCH 4/8] testkit: mirror RESET like the session; assert the LIMIT 0 literal Bare RESET now unsets every key set earlier in the session (it left SET keys behind), and RESET key matches base keys case-insensitively, as the session does; a test fails without the fix. The LIMIT 0 analyzer test now asserts the resolved Limit holds the literal 0. Signed-off-by: techysneha14 <343708768+shehatathe@users.noreply.github.com> --- crates/krishiv-sql/tests/analyzer.rs | 25 ++++- .../src/golden/session_engine.rs | 97 ++++++++++++++++--- 2 files changed, 103 insertions(+), 19 deletions(-) diff --git a/crates/krishiv-sql/tests/analyzer.rs b/crates/krishiv-sql/tests/analyzer.rs index 98a4b9bfe..a0540d693 100644 --- a/crates/krishiv-sql/tests/analyzer.rs +++ b/crates/krishiv-sql/tests/analyzer.rs @@ -20,8 +20,8 @@ use krishiv_plan::analyzer::{ ResolutionConf, TableColumn, }; use krishiv_plan::{ - AttrId, Builtin, Expr, ExprNode, FunctionId, JoinCondition, JoinKind, LogicalPlan, PlanNode, - ResolvedExpr, SourceId, + AttrId, Builtin, Expr, ExprNode, FunctionId, JoinCondition, JoinKind, Literal, LogicalPlan, + PlanNode, ResolvedExpr, SourceId, }; use krishiv_sql::{ParserOptions, parse_and_lower, redact_sql}; use serde_json::Value; @@ -443,6 +443,20 @@ fn repeated_correlation_keys_stay_unique() { /// A foldable `LIMIT` that is negative or NULL fails analysis as Spark's /// `checkLimitLikeClause` does (it used to reach the planner). +/// The `LIMIT` count of `plan`, wherever it sits. +fn limit_of(plan: &Arc) -> Option> { + if let PlanNode::Limit { limit, .. } = &plan.node { + return Some(Arc::clone(limit)); + } + let mut found = None; + plan.for_each_child(&mut |c| { + if found.is_none() { + found = limit_of(c); + } + }); + found +} + #[test] fn negative_and_null_limits_fail_analysis() { let g = goldens(); @@ -464,5 +478,10 @@ fn negative_and_null_limits_fail_analysis() { e.error_class().name(), "INVALID_LIMIT_LIKE_EXPRESSION.IS_NULL" ); - assert!(analyze(&g, "SELECT a FROM t LIMIT 0", ResolutionConf::default()).is_ok()); + let a = analyze(&g, "SELECT a FROM t LIMIT 0", ResolutionConf::default()).unwrap(); + let limit = limit_of(a.plan.root()).expect("a Limit node"); + assert!( + matches!(&limit.node, ExprNode::Literal(Literal::Integer(0))), + "{limit:?}" + ); } diff --git a/crates/krishiv-testkit/src/golden/session_engine.rs b/crates/krishiv-testkit/src/golden/session_engine.rs index 05b10ffdd..74b2b6ace 100644 --- a/crates/krishiv-testkit/src/golden/session_engine.rs +++ b/crates/krishiv-testkit/src/golden/session_engine.rs @@ -136,27 +136,49 @@ impl SessionEngine { if first.eq_ignore_ascii_case("RESET") { let key = sql.get(5..).map(str::trim).filter(|k| !k.is_empty()); match key { - None => self.conf.clone_from(&self.base), + None => { + let old = std::mem::replace(&mut self.conf, self.base.clone()); + if let Some(s) = &self.session { + let conf = s.conf(); + // Every key the run set, including ones `base` does + // not hold: unsetting only `base` keys would leave a + // `SET` key behind in the session. + for (k, _) in &old { + drop(conf.unset(k)); + } + for (k, v) in &self.base { + drop(conf.set(k, v)); + } + } + } Some(key) => { - self.conf.retain(|(k, _)| !k.eq_ignore_ascii_case(key)); - if let Some(kv) = self.base.iter().rev().find(|(k, _)| k == key) { + let mut removed: Vec = Vec::new(); + self.conf.retain(|(k, _)| { + let hit = k.eq_ignore_ascii_case(key); + if hit { + removed.push(k.clone()); + } + !hit + }); + let base = self + .base + .iter() + .rev() + .find(|(k, _)| k.eq_ignore_ascii_case(key)) + .cloned(); + if let Some(kv) = &base { self.conf.push(kv.clone()); } - } - } - if let Some(s) = &self.session { - let conf = s.conf(); - match key { - Some(key) => match self.base.iter().rev().find(|(k, _)| k == key) { - Some((k, v)) => drop(conf.set(k, v)), - None => drop(conf.unset(key)), - }, - None => { - for (k, _) in &self.conf { + if let Some(s) = &self.session { + let conf = s.conf(); + // Unset under the stored spellings: the session keeps + // an unregistered key under the case it was set with. + for k in &removed { drop(conf.unset(k)); } - for (k, v) in &self.base { - drop(conf.set(k, v)); + match base { + Some((k, v)) => drop(conf.set(&k, &v)), + None => drop(conf.unset(key)), } } } @@ -631,6 +653,49 @@ mod tests { Ok(()) } + #[test] + fn reset_clears_set_keys_and_ignores_case() -> R { + let mut e = engine(vec![]).map_err(err)?; + let session_get = + |e: &SessionEngine, key: &str| e.session.as_ref().and_then(|s| s.conf().get(key)); + // A bare `RESET` unsets a `SET` key the run never had, in the + // session as well as in `conf`. + e.apply_set("SET spark.sql.ansi.enabled = false"); + assert_eq!( + session_get(&e, "spark.sql.ansi.enabled").as_deref(), + Some("false") + ); + e.apply_set("RESET"); + assert_eq!(e.conf, e.base); + assert_eq!( + session_get(&e, "spark.sql.ansi.enabled").as_deref(), + Some("true") + ); + // `RESET key` matches case-insensitively, in both directions. + e.apply_set("SET My.Custom.Key = 1"); + e.apply_set("RESET my.custom.key"); + assert!( + e.conf + .iter() + .all(|(k, _)| !k.eq_ignore_ascii_case("My.Custom.Key")) + ); + assert_eq!(session_get(&e, "My.Custom.Key"), None); + assert_eq!(session_get(&e, "my.custom.key"), None); + // ... and restores a base value it finds case-insensitively. + e.base + .push(("my.base.key".to_owned(), "base-val".to_owned())); + e.conf + .push(("my.base.key".to_owned(), "base-val".to_owned())); + if let Some(s) = &e.session { + drop(s.conf().set("my.base.key", "base-val")); + } + e.apply_set("SET my.base.key = changed"); + e.apply_set("RESET MY.BASE.KEY"); + assert_eq!(e.conf_value("my.base.key"), Some("base-val")); + assert_eq!(session_get(&e, "my.base.key").as_deref(), Some("base-val")); + Ok(()) + } + #[test] fn fixtures_with_session_types_are_registered() -> R { let mut e = engine(vec![ From 2f01dd44f815128f2c978c2dea241538a88c8e3f Mon Sep 17 00:00:00 2001 From: techysneha14 <343708768+shehatathe@users.noreply.github.com> Date: Thu, 22 Oct 2026 22:53:38 +0200 Subject: [PATCH 5/8] testkit: use a non-word in the parse-error test (typos lint) Signed-off-by: techysneha14 <343708768+shehatathe@users.noreply.github.com> --- crates/krishiv-testkit/src/golden/session_engine.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/krishiv-testkit/src/golden/session_engine.rs b/crates/krishiv-testkit/src/golden/session_engine.rs index 74b2b6ace..727df6ed7 100644 --- a/crates/krishiv-testkit/src/golden/session_engine.rs +++ b/crates/krishiv-testkit/src/golden/session_engine.rs @@ -612,7 +612,7 @@ mod tests { assert_eq!(got.class.as_deref(), Some("TABLE_OR_VIEW_NOT_FOUND")); assert_eq!(got.sql_state.as_deref(), Some("42P01")); assert!(e.parse("SELECT 1").is_ok()); - let got = e.parse("SELEC 1").unwrap_err(); + let got = e.parse("XYZZY 1").unwrap_err(); assert_eq!(got.class.as_deref(), Some("PARSE_SYNTAX_ERROR")); // `"a"` is a string, until double-quoted identifiers are on. assert!(e.parse("SELECT \"a\" FROM t").is_ok()); From 72274009ad8265adb502a27ace694f3c8c204b77 Mon Sep 17 00:00:00 2001 From: gopal tathe <44522021+techgopal@users.noreply.github.com> Date: Fri, 23 Oct 2026 15:54:02 +0200 Subject: [PATCH 6/8] plan: fold arithmetic LIMIT counts and reject unfoldable; testkit: keep golden timeouts out of the ratchet Signed-off-by: gopal tathe <44522021+techgopal@users.noreply.github.com> --- crates/krishiv-plan/src/analyzer/fold.rs | 225 +++++++++++++++++- crates/krishiv-plan/src/analyzer/resolve.rs | 13 +- crates/krishiv-sql/tests/analyzer.rs | 55 +++++ crates/krishiv-testkit/src/golden/report.rs | 1 + crates/krishiv-testkit/src/golden/run.rs | 78 +++++- .../src/golden/session_engine.rs | 14 +- .../krishiv-testkit/tests/golden_ratchet.rs | 13 + 7 files changed, 379 insertions(+), 20 deletions(-) diff --git a/crates/krishiv-plan/src/analyzer/fold.rs b/crates/krishiv-plan/src/analyzer/fold.rs index 25c0289ce..ae4e945fc 100644 --- a/crates/krishiv-plan/src/analyzer/fold.rs +++ b/crates/krishiv-plan/src/analyzer/fold.rs @@ -24,15 +24,52 @@ use krishiv_kernels::cast::{CastMode as KernelMode, CastOptions, FixedOffset, ca use krishiv_types::DataType; use super::Constant; -use crate::{CastMode, Expr, ExprNode, Literal}; +use crate::{Builtin, CastMode, Expr, ExprNode, FunctionId, FunctionKind, Literal, ResolvedExpr}; -/// The value of `e` as a constant, when it is a literal or a cast of one. +/// The value of `e` as a constant, when it is a literal, a cast of one, +/// or integral `+`/`-`/`*`/unary `-` over constants (what a `LIMIT` +/// count folds before Spark's `checkLimitLikeClause`). pub(super) fn constant(e: &Expr, ansi: bool) -> Option { + if let ExprNode::Resolved(ResolvedExpr::Function(f)) = &e.node { + let op = match &f.id { + FunctionId::Builtin(op) => *op, + _ => return None, + }; + match (op, f.args.as_slice()) { + (Builtin::Add | Builtin::Subtract | Builtin::Multiply, [a, b]) => { + return arith(op, a, b, ansi); + } + (Builtin::Negative, [a]) => return negative(a, ansi), + _ => return None, + } + } let folded = match &e.node { ExprNode::Literal(Literal::Null(_)) => return Some(Constant::Null), ExprNode::Literal(Literal::Boolean(v)) => return Some(Constant::Boolean(*v)), ExprNode::Literal(Literal::String(v)) => return Some(Constant::String(v.clone())), - ExprNode::Literal(_) | ExprNode::Cast { .. } => fold(e, ansi)?, + ExprNode::Literal(_) => fold(e, ansi)?, + ExprNode::Cast { expr, to, mode } => match fold(e, ansi) { + Some(folded) => folded, + None => { + // A cast of an arithmetic constant (`CAST(1 - 2 AS INT)`): + // fold the inner constant through the cast kernels so + // overflow and ANSI/legacy rules match a cast of a literal. + match constant(expr, ansi)? { + Constant::Null => return Some(Constant::Null), + Constant::Error(err) => return Some(Constant::Error(err)), + Constant::Integral(v) => { + let inner = Expr::new(ExprNode::Literal(Literal::Long(v))); + let tmp = Expr::new(ExprNode::Cast { + expr: Arc::new(inner), + to: to.clone(), + mode: *mode, + }); + fold(&tmp, ansi)? + } + _ => return None, + } + } + }, _ => return None, }; Some(match folded.and_then(|a| value(&a, ansi)) { @@ -41,6 +78,66 @@ pub(super) fn constant(e: &Expr, ansi: bool) -> Option { }) } +/// Whether `e` is foldable for Spark's `checkLimitLikeClause`: deterministic +/// with no input references, so it can be evaluated without rows. Columns, +/// subqueries and nondeterministic or aggregate calls are not foldable. +/// Iterative over an explicit stack so deep expressions do not overflow the +/// call stack (the analyzer resolves deep plans on a small stack). +pub(super) fn is_foldable(e: &Expr) -> bool { + let mut stack = vec![e]; + while let Some(x) = stack.pop() { + match &x.node { + ExprNode::Literal(_) => {} + ExprNode::Cast { expr, .. } + | ExprNode::Alias { expr, .. } + | ExprNode::Resolved(ResolvedExpr::Alias { expr, .. }) => { + stack.push(expr); + } + ExprNode::Resolved(ResolvedExpr::Function(f)) => { + if f.kind != FunctionKind::Scalar + || !f.deterministic + || f.filter.is_some() + || f.distinct + { + return false; + } + stack.extend(f.args.iter().map(|a| &**a)); + } + _ => return false, + } + } + true +} + +/// Integral `+`/`-`/`*` over constants, with NULL propagation. Overflow is +/// not folded (the expression stays foldable but unevaluated, as before). +fn arith(op: Builtin, a: &Expr, b: &Expr, ansi: bool) -> Option { + let (x, y) = match (constant(a, ansi)?, constant(b, ansi)?) { + (Constant::Null, _) | (_, Constant::Null) => return Some(Constant::Null), + (Constant::Error(e), _) | (_, Constant::Error(e)) => { + return Some(Constant::Error(e)); + } + (Constant::Integral(x), Constant::Integral(y)) => (x, y), + _ => return None, + }; + let v = match op { + Builtin::Add => x.checked_add(y), + Builtin::Subtract => x.checked_sub(y), + _ => x.checked_mul(y), + }?; + Some(Constant::Integral(v)) +} + +/// Unary `-` over a constant, with NULL propagation. +fn negative(a: &Expr, ansi: bool) -> Option { + match constant(a, ansi)? { + Constant::Null => Some(Constant::Null), + Constant::Error(e) => Some(Constant::Error(e)), + Constant::Integral(v) => v.checked_neg().map(Constant::Integral), + _ => None, + } +} + /// A folded array as a constant. A fractional value is what the implicit /// cast to `INT` of an integral argument gives (the scale of `round`). fn value(a: &ArrayRef, ansi: bool) -> Result { @@ -344,4 +441,126 @@ mod tests { assert_eq!(constant(&col, ansi), None); assert_eq!(constant(&cast_of(col, DataType::Float), ansi), None); } + + fn resolved_arith(op: crate::Builtin, args: Vec, data_type: DataType) -> Expr { + use crate::{FunctionId, FunctionKind, ResolvedExpr, ResolvedFunction}; + let f = ResolvedFunction { + id: FunctionId::Builtin(op), + kind: FunctionKind::Scalar, + args: args.into_iter().map(std::sync::Arc::new).collect(), + distinct: false, + filter: None, + data_type, + nullable: false, + deterministic: true, + }; + Expr::new(ExprNode::Resolved(ResolvedExpr::Function(f))) + } + + fn sub(a: Expr, b: Expr) -> Expr { + resolved_arith(crate::Builtin::Subtract, vec![a, b], DataType::Integer) + } + + /// Integral `+`/`-`/`*`/unary `-` fold, with NULL propagation and error + /// passthrough; overflow stays unfoldered as before. + #[test] + fn arithmetic_constants_fold_for_limit_checks() { + use crate::Builtin; + let ansi = true; + let n = |v: i64| Some(Constant::Integral(v)); + let one = lit(Literal::Integer(1)); + let two = lit(Literal::Integer(2)); + // `1 - 2` is -1, `1 + 2` is 3, `2 * 3` is 6. + assert_eq!(constant(&sub(one.clone(), two.clone()), ansi), n(-1)); + assert!(is_foldable(&sub(one.clone(), two.clone()))); + let add = resolved_arith( + Builtin::Add, + vec![one.clone(), two.clone()], + DataType::Integer, + ); + assert_eq!(constant(&add, ansi), n(3)); + let mul = resolved_arith( + Builtin::Multiply, + vec![two, lit(Literal::Integer(3))], + DataType::Integer, + ); + assert_eq!(constant(&mul, ansi), n(6)); + // `NULL + 1` stays NULL. + let null = cast(Literal::Null(None), DataType::Integer); + assert_eq!( + constant(&sub(null.clone(), one.clone()), ansi), + Some(Constant::Null) + ); + assert!(is_foldable(&sub(null, one.clone()))); + // An error inside stays an error for the reader to raise. + let bad = cast(Literal::String("x".to_owned()), DataType::Integer); + assert!(matches!( + constant(&sub(bad.clone(), one.clone()), ansi), + Some(Constant::Error(_)) + )); + assert!(is_foldable(&sub(bad, one.clone()))); + // Overflow is not folded, but stays foldable. + let max = lit(Literal::Long(i64::MAX)); + let overflow = sub(max, lit(Literal::Integer(-1))); + assert_eq!(constant(&overflow, ansi), None); + assert!(is_foldable(&overflow)); + // A non-integral arithmetic result is not a limit constant, but the + // count is still foldable. + let boolean = resolved_arith( + Builtin::Add, + vec![lit(Literal::Boolean(true)), one.clone()], + DataType::Boolean, + ); + assert_eq!(constant(&boolean, ansi), None); + assert!(is_foldable(&boolean)); + // Unary minus folds as well, including NULL and error passthrough. + let neg = resolved_arith(Builtin::Negative, vec![one], DataType::Integer); + assert_eq!(constant(&neg, ansi), n(-1)); + assert!(is_foldable(&neg)); + let neg_null = resolved_arith( + Builtin::Negative, + vec![cast(Literal::Null(None), DataType::Integer)], + DataType::Integer, + ); + assert_eq!(constant(&neg_null, ansi), Some(Constant::Null)); + let neg_bad = resolved_arith( + Builtin::Negative, + vec![cast(Literal::String("x".to_owned()), DataType::Integer)], + DataType::Integer, + ); + assert!(matches!(constant(&neg_bad, ansi), Some(Constant::Error(_)))); + let neg_bool = resolved_arith( + Builtin::Negative, + vec![lit(Literal::Boolean(true))], + DataType::Boolean, + ); + assert_eq!(constant(&neg_bool, ansi), None); + assert!(is_foldable(&neg_bool)); + } + + /// What `LIMIT` accepts as foldable: literals and deterministic scalar + /// calls of foldable arguments, nothing with rows or state. + #[test] + fn limit_foldability_needs_no_rows_or_state() { + assert!(is_foldable(&lit(Literal::Integer(1)))); + assert!(is_foldable(&cast(Literal::Integer(1), DataType::Integer))); + let one = lit(Literal::Integer(1)); + assert!(is_foldable(&sub(one.clone(), one.clone()))); + let col = Expr::new(ExprNode::Column(crate::ColumnRef { + name: vec!["a".to_owned()], + plan_id: None, + })); + assert!(!is_foldable(&col)); + assert!(!is_foldable(&cast_of(col, DataType::Integer))); + // A cast that the kernels do not implement is still foldable when its + // input is, but has no constant. + let to_string = cast_of(one, DataType::String); + assert!(is_foldable(&to_string)); + assert_eq!(constant(&to_string, true), None); + // A cast of a non-numeric literal has no constant either, but stays + // foldable. + let bool_to_string = cast_of(lit(Literal::Boolean(true)), DataType::String); + assert!(is_foldable(&bool_to_string)); + assert_eq!(constant(&bool_to_string, true), None); + } } diff --git a/crates/krishiv-plan/src/analyzer/resolve.rs b/crates/krishiv-plan/src/analyzer/resolve.rs index 8d7e3e9b3..dede6d7b2 100644 --- a/crates/krishiv-plan/src/analyzer/resolve.rs +++ b/crates/krishiv-plan/src/analyzer/resolve.rs @@ -349,13 +349,24 @@ impl Resolver<'_> { } /// Spark's `checkLimitLikeClause` on a bound `LIMIT` count: it must be - /// an `INT`, and a foldable count must be neither NULL nor negative. + /// foldable, then an `INT`, and its folded value must be neither NULL + /// nor negative. A foldable count that does not fold here (for example + /// an overflowing `+`) stays accepted, as before. /// Kept out of the resolver's recursive match so its locals do not /// grow every frame of a deep plan. #[inline(never)] fn check_limit(&self, b: &Bound, origin: Origin) -> Result<(), AnalysisError> { let expr = || format!("\"{}\"", super::exprs::pretty(&b.shown())); let name = "limit".to_owned(); + if !super::fold::is_foldable(&b.expr) { + return Err(AnalysisError::new( + krishiv_common::error::InvalidLimitLikeExpressionIsUnfoldable { + expr: expr(), + name, + }, + origin, + )); + } if b.ty.data_type != Some(krishiv_types::DataType::Integer) { return Err(AnalysisError::new( krishiv_common::error::InvalidLimitLikeExpressionDataType { diff --git a/crates/krishiv-sql/tests/analyzer.rs b/crates/krishiv-sql/tests/analyzer.rs index a0540d693..51ecc68e4 100644 --- a/crates/krishiv-sql/tests/analyzer.rs +++ b/crates/krishiv-sql/tests/analyzer.rs @@ -485,3 +485,58 @@ fn negative_and_null_limits_fail_analysis() { "{limit:?}" ); } + +/// `LIMIT` folds arithmetic before Spark's checks, and rejects counts that +/// cannot be evaluated without rows. +#[test] +fn limit_folds_arithmetic_and_rejects_unfoldable_counts() { + let g = goldens(); + let err = |sql: &str| { + analyze(&g, sql, ResolutionConf::default()) + .unwrap_err() + .error + }; + // `1 - 2` is a foldable negative count, not a passing limit. + let e = err("SELECT a FROM t LIMIT 1 - 2"); + assert_eq!( + e.error_class().name(), + "INVALID_LIMIT_LIKE_EXPRESSION.IS_NEGATIVE" + ); + assert_eq!(e.sql_state(), Some("42K0E")); + assert!(e.message().contains("but got -1"), "{}", e.message()); + // `NULL + 1` stays NULL, and a cast of arithmetic folds through the kernels. + let e = err("SELECT a FROM t LIMIT CAST(NULL AS INT) + 1"); + assert_eq!( + e.error_class().name(), + "INVALID_LIMIT_LIKE_EXPRESSION.IS_NULL" + ); + let e = err("SELECT a FROM t LIMIT CAST(1 - 2 AS INT)"); + assert_eq!( + e.error_class().name(), + "INVALID_LIMIT_LIKE_EXPRESSION.IS_NEGATIVE" + ); + assert!(e.message().contains("but got -1"), "{}", e.message()); + let e = err("SELECT a FROM t LIMIT CAST(CAST(NULL AS INT) + 1 AS INT)"); + assert_eq!( + e.error_class().name(), + "INVALID_LIMIT_LIKE_EXPRESSION.IS_NULL" + ); + // Unary minus over a constant folds as well. + let e = err("SELECT a FROM t LIMIT -(1)"); + assert_eq!( + e.error_class().name(), + "INVALID_LIMIT_LIKE_EXPRESSION.IS_NEGATIVE" + ); + let e = err("SELECT a FROM t LIMIT -(CAST(NULL AS INT))"); + assert_eq!( + e.error_class().name(), + "INVALID_LIMIT_LIKE_EXPRESSION.IS_NULL" + ); + // A scalar subquery binds but is not foldable. + let e = err("SELECT a FROM t LIMIT (SELECT 1)"); + assert_eq!( + e.error_class().name(), + "INVALID_LIMIT_LIKE_EXPRESSION.IS_UNFOLDABLE" + ); + assert_eq!(e.sql_state(), Some("42K0E")); +} diff --git a/crates/krishiv-testkit/src/golden/report.rs b/crates/krishiv-testkit/src/golden/report.rs index 684532791..d8a6dd735 100644 --- a/crates/krishiv-testkit/src/golden/report.rs +++ b/crates/krishiv-testkit/src/golden/report.rs @@ -182,6 +182,7 @@ mod tests { unclassified_errors: 1, runs: 2, cases: Vec::new(), + timeouts: Vec::new(), }], excluded: vec![SkippedFile { name: "udf/x".into(), diff --git a/crates/krishiv-testkit/src/golden/run.rs b/crates/krishiv-testkit/src/golden/run.rs index 630dec670..f8472cc87 100644 --- a/crates/krishiv-testkit/src/golden/run.rs +++ b/crates/krishiv-testkit/src/golden/run.rs @@ -28,6 +28,12 @@ use super::parse::{Expected, ExpectedError, ParseError, Statement, parse_results use super::setup::{FileSetup, SessionSetup}; use super::{GoldenPair, GoldenSet, Jdk}; +/// The error class a statement that exceeds the runner's time limit fails +/// with. It is a harness failure, never a baseline failure: [`FileResult`] +/// keeps timeouts out of [`Case`] so [`crate::golden::known_failures`] never +/// lists them, and the ratchet never asks for them to be removed. +pub const TIMEOUT_CLASS: &str = "KRISHIV_GOLDEN_TIMEOUT"; + /// An engine failure on one statement. #[derive(Debug, Clone, PartialEq, Eq)] pub struct EngineError { @@ -142,6 +148,9 @@ pub struct FileResult { pub unclassified_errors: u64, /// Per-statement outcomes, in file order (the counted statements only). pub cases: Vec, + /// Statements that timed out, kept out of the baseline comparison and + /// reported as harness failures instead. + pub timeouts: Vec, } /// What one statement of a file scored, merged over the file's runs. @@ -331,6 +340,7 @@ struct Outcome { result: Option, unclassified: bool, detail: String, + timeout: bool, } impl Outcome { @@ -350,6 +360,7 @@ impl Outcome { } else { self.detail }, + timeout: self.timeout || other.timeout, } } } @@ -398,6 +409,17 @@ pub fn run_file_with( }; let merged = merged.unwrap_or_default().into_iter().zip(kept).enumerate(); for (index, o) in merged.filter_map(|(i, (o, k))| k.then_some((i, o))) { + let case = Case { + index: u32::try_from(index).unwrap_or(u32::MAX), + parse: o.parse, + negative: o.negative, + result: o.result, + detail: o.detail.clone(), + }; + if o.timeout { + file.timeouts.push(case); + continue; + } for (tally, v) in [ (&mut file.parse, o.parse), (&mut file.negative, o.negative), @@ -408,15 +430,9 @@ pub fn run_file_with( } } file.unclassified_errors += u64::from(o.unclassified); - let mut case = Case { - index: u32::try_from(index).unwrap_or(u32::MAX), - parse: o.parse, - negative: o.negative, - result: o.result, - detail: String::new(), - }; - if !case.passed() { - case.detail = o.detail; + let mut case = case; + if case.passed() { + case.detail.clear(); } file.cases.push(case); } @@ -460,6 +476,10 @@ fn outcome( parsed: bool, executed: Option<(Result, &Masker)>, ) -> Outcome { + let is_timeout = matches!( + &executed, + Some((Err(e), _)) if e.class.as_deref() == Some(TIMEOUT_CLASS) + ); let parse_detail = || { if parsed { String::new() @@ -485,6 +505,7 @@ fn outcome( } else { format!("{}{why}", parse_detail()) }, + timeout: is_timeout, ..Outcome::default() } } @@ -511,6 +532,7 @@ fn outcome( } else { why }, + timeout: is_timeout, ..Outcome::default() } } @@ -836,4 +858,42 @@ mod tests { assert!(e.parse("x").is_ok() && e.execute("x").is_err()); Ok(()) } + + /// An engine that times out on every statement. + struct TimeoutEngine; + + impl Engine for TimeoutEngine { + fn name(&self) -> &str { + "timeout" + } + fn reset(&mut self, _setup: &SessionSetup) -> Result<(), EngineError> { + Ok(()) + } + fn parse(&mut self, _sql: &str) -> Result<(), EngineError> { + Ok(()) + } + fn execute(&mut self, sql: &str) -> Result { + let _ = sql; + Err(EngineError { + class: Some(TIMEOUT_CLASS.to_owned()), + sql_state: None, + message: "no answer within 0ns".to_owned(), + }) + } + } + + #[test] + fn timeouts_stay_out_of_the_baseline_comparison() -> R { + let statements = parse_results(OUT)?; + let f = run_file(&mut TimeoutEngine, "t", &statements, &plain()); + // Timeouts are harness failures: no tallies, no baseline cases. + assert!(f.timeouts.len() == 3, "{f:?}"); + assert!(f.cases.is_empty(), "{f:?}"); + assert_eq!((f.parse.total, f.negative.total, f.result.total), (0, 0, 0)); + assert_eq!(f.unclassified_errors, 0); + let detail = &f.timeouts[0].detail; + assert!(detail.contains(TIMEOUT_CLASS), "{detail}"); + assert_eq!(f.timeouts[0].index, 0); + Ok(()) + } } diff --git a/crates/krishiv-testkit/src/golden/session_engine.rs b/crates/krishiv-testkit/src/golden/session_engine.rs index 727df6ed7..f04329d4a 100644 --- a/crates/krishiv-testkit/src/golden/session_engine.rs +++ b/crates/krishiv-testkit/src/golden/session_engine.rs @@ -15,8 +15,9 @@ //! answer. Rows are rendered by [`super::cell`] from the batches and the result's Spark types; //! row order counts when [`super::sorted::is_semantically_sorted`] says so on the analyzed plan. //! Each statement runs under a wall-clock limit ([`SessionEngine::with_timeout`]): a statement -//! that exceeds it is cancelled (its future is dropped, which cancels the query) and fails with -//! [`TIMEOUT_CLASS`]. +//! that exceeds it is cancelled (its future is dropped, which cancels the query) and recorded +//! separately as a harness failure ([`super::run::TIMEOUT_CLASS`]), kept out of the frozen +//! baseline comparison so a slow runner cannot fail the ratchet without a code change. use std::sync::Arc; use std::time::Duration; @@ -40,12 +41,11 @@ use super::run::{Engine, EngineError, QueryOutput}; use super::setup::SessionSetup; use super::sorted::is_semantically_sorted; -/// The error class a statement that exceeds the time limit fails with (not a Spark class, so it -/// never matches an expected error). -pub const TIMEOUT_CLASS: &str = "KRISHIV_GOLDEN_TIMEOUT"; +pub use super::run::TIMEOUT_CLASS; -/// The default per-statement time limit. -pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(30); +/// The default per-statement time limit: high enough that only a stuck query +/// hits it, so a hit fails the harness instead of the baseline comparison. +pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(300); /// The memory limit of each session: far above what any golden statement needs, and below the /// cap the harness runs under, so a runaway query fails inside the engine. diff --git a/crates/krishiv-testkit/tests/golden_ratchet.rs b/crates/krishiv-testkit/tests/golden_ratchet.rs index e4aa22ccf..63093892b 100644 --- a/crates/krishiv-testkit/tests/golden_ratchet.rs +++ b/crates/krishiv-testkit/tests/golden_ratchet.rs @@ -27,6 +27,19 @@ fn session_engine_matches_the_frozen_baseline() -> R { let mut engine = SessionEngine::new().map_err(|e| e.message)?; let result = run(&mut engine, &set, &manifest)?; assert!(result.failed_files.is_empty(), "{:?}", result.failed_files); + let timeouts: Vec = result + .files + .iter() + .flat_map(|f| { + f.timeouts + .iter() + .map(move |c| format!("{}#{}: {}", f.name, c.index, c.detail)) + }) + .collect(); + assert!( + timeouts.is_empty(), + "harness timeouts, not baseline failures: {timeouts:?}" + ); let ratchet = known.check(&result); assert!(ratchet.is_clean(), "{}", ratchet.describe()); Ok(()) From b9fede1b1b3c2b89b5948707ea48aa91db6e54d2 Mon Sep 17 00:00:00 2001 From: techysneha14 <343708768+shehatathe@users.noreply.github.com> Date: Sat, 24 Oct 2026 07:05:44 +0200 Subject: [PATCH 7/8] testkit: refresh the golden baseline after merging main Main now runs SET through Session::sql, so the session-engine test asserts the command succeeds and reaches the session's conf instead of a parse error. Re-record the frozen baseline: 2903 statements main fixed leave the list; cte#24 (an unused CTE over a missing relation no longer raises TABLE_OR_VIEW_NOT_FOUND) joins the analyzer bug category, and two statements that now depend on SET handling move category. Signed-off-by: techysneha14 <343708768+shehatathe@users.noreply.github.com> --- .../src/golden/session_engine.rs | 17 +- tests/spark-golden/known-failures.json | 252 +++++++++--------- 2 files changed, 134 insertions(+), 135 deletions(-) diff --git a/crates/krishiv-testkit/src/golden/session_engine.rs b/crates/krishiv-testkit/src/golden/session_engine.rs index f04329d4a..655967219 100644 --- a/crates/krishiv-testkit/src/golden/session_engine.rs +++ b/crates/krishiv-testkit/src/golden/session_engine.rs @@ -637,12 +637,17 @@ mod tests { Ok(out.rows[0][0].clone()) }; e.apply_set("SET spark.sql.session.timeZone=UTC"); - // The command itself is the session's answer: it does not parse yet. - let set = e - .execute("SET spark.sql.session.timeZone=+01:00") - .map(drop) - .unwrap_err(); - assert_eq!(set.class.as_deref(), Some("PARSE_SYNTAX_ERROR")); + // The session runs the command itself (`Session::sql` handles + // `SET`), and the mirrored value reaches the session's conf. + e.execute("SET spark.sql.session.timeZone=+01:00") + .map_err(err)?; + assert_eq!( + e.session + .as_ref() + .and_then(|s| s.conf().get("spark.sql.session.timeZone")) + .as_deref(), + Some("+01:00") + ); assert_eq!(ts(&mut e)?, "2020-01-01 00:00:00"); e.apply_set("RESET spark.sql.session.timeZone"); e.apply_set("SET spark.sql.session.timeZone=UTC"); diff --git a/tests/spark-golden/known-failures.json b/tests/spark-golden/known-failures.json index dc4e0e2b4..40af36212 100644 --- a/tests/spark-golden/known-failures.json +++ b/tests/spark-golden/known-failures.json @@ -3,7 +3,7 @@ "analyzer-bugs": { "kind": "bug", "owner": "analyzer follow-up of P2-T071a", - "summary": "analyzer resolution differs from Spark: unused CTE definitions are analyzed (cte#50), GROUP BY a backquoted output alias `1`, LIMIT over a column reports UNRESOLVED_COLUMN instead of IS_UNFOLDABLE" + "summary": "analyzer resolution differs from Spark: an unused CTE definition over a missing relation is not analyzed, so TABLE_OR_VIEW_NOT_FOUND is not raised (cte#16, cte#24), GROUP BY a backquoted output alias `1`, LIMIT over a column reports UNRESOLVED_COLUMN instead of IS_UNFOLDABLE" }, "cast-matrix": { "kind": "unsupported", @@ -25,11 +25,6 @@ "summary": "datetime functions and literals beyond P2a (TIMESTAMP literals, date/timestamp arithmetic, patterns, unit-argument forms)", "task": "P2-T025" }, - "datetime-bugs": { - "kind": "bug", - "owner": "datetime follow-up of P2-T025a", - "summary": "date_add/date_sub accept a fractional string day count with ANSI off; Spark raises SECOND_FUNCTION_ARGUMENT_NOT_INTEGER" - }, "depends-on-command": { "kind": "unsupported", "summary": "queries that read a table, view, function or variable an earlier command of the file creates (the command failed, so the query fails or reads the shared fixture of the same name)", @@ -241,11 +236,6 @@ "detail": "UNRESOLVED_COLUMN.*`key`", "file": "^limit$" }, - { - "category": "datetime-bugs", - "detail": "^no error", - "file": "^nonansi/date$" - }, { "category": "datetime", "detail": "WRONG_NUM_ARGS.*`(date_add|dateadd|datediff|date_diff)`|Cannot resolve routine `(timestampadd|timestampdiff|timediff)`" @@ -463,12 +453,17 @@ { "category": "output-names", "detail": "^schema " + }, + { + "category": "analyzer-bugs", + "detail": "^no error", + "file": "^cte$" } ], "spark_tag": "v4.2.0", "cases": { "alias-resolution-edge-cases": {"depends-on-command":[6,7],"fn-string":[2,3],"query-features":[4,5],"sql-commands":[0,1,8,9]}, - "array": {"depends-on-command":[1,2,3,5,6,7,8,11],"fn-array":[9,10,12,13,14,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,59,60,63,64,65,66,67,68,69,70,71,74,76,77,78,79,80,83,85,86,87],"fn-string":[15,16,17,18,19,20,21],"nested-interval-types":[22,23,52,72,73,75,81,82,84],"query-features":[62],"sql-commands":[0,4,58,61]}, + "array": {"depends-on-command":[1,2,3,5,6,7,8,11],"fn-array":[9,10,12,13,14,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,59,60,63,64,65,66,67,68,69,70,71,74,76,77,78,79,80,83,85,86,87],"fn-string":[15,16,17,18,19,20,21],"nested-interval-types":[22,23,52,72,73,75,81,82,84],"query-features":[62],"sql-commands":[0,4]}, "binary": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, "binary_base64": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, "binary_basic": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, @@ -476,7 +471,7 @@ "binary_hex_discrete": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, "bitwise": {"depends-on-command":[21,22,23,24,25,26],"fn-bitwise-predicate":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,27,28,29,30,31,32,33,34,43,44,45],"nested-interval-types":[40,41,42],"sql-commands":[20]}, "cast": {"cast-matrix":[58,59,60,66,67,70,71,130,131],"fn-string":[28,29,30,31,32,33,34,35,36,124,125],"nested-interval-types":[39,40,41,43,44,72,73,74,75,76,77,78,79,80,81,82,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,126,127,132,133,134,135,143],"query-features":[83,87],"sql-commands":[37,38],"time-geo-types":[104,105,106,107,108,109,110,111,112,113,114,115,116,136,137,138,139,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163]}, - "change-column": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27]}, + "change-column": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,23,24,25,26,27]}, "charvarchar": {"depends-on-command":[50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80],"fn-number-format":[87,88,89],"fn-string":[85,86],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,81,82,83,84]}, "collations-aliases": {"depends-on-command":[16,17,18,19,20,21,22,23,24,25,26,28,29],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,27,30,31]}, "collations-basic": {"depends-on-command":[8,9,10,11,12,13,14,18,34,35,59,60,61,62,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132],"parser-pipe-collate":[21,22,23,24,25,26,27,28,29,30,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56],"sql-commands":[0,1,2,3,4,5,6,7,15,16,17,19,20,31,32,33,36,57,58,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,133,134,135,136]}, @@ -484,42 +479,42 @@ "collations-string-functions": {"depends-on-command":[21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,148,149,150]}, "column-resolution-aggregate": {"depends-on-command":[2,3,4,5,6,7,8,9,10],"sql-commands":[0,1]}, "column-resolution-sort": {"depends-on-command":[2,3,4],"sql-commands":[0,1]}, - "columnresolution": {"depends-on-command":[7,8,9,10,11,12,14,15,16,17,18,20,21,22,24,25,26,27,31,32,34,35,37,42,43,44,45,46,47,48,49,50,51],"sql-commands":[0,1,2,3,4,5,6,13,19,23,28,29,30,33,36,38,39,40,41,52,53,54]}, - "columnresolution-negative": {"depends-on-command":[8,9,10,11,12,14,15,16,17,18,21,22,23,25,30,35],"sql-commands":[0,1,2,3,4,5,6,7,13,19,20,24,26,27,28,29,31,32,33,34,36,37]}, - "columnresolution-views": {"depends-on-command":[1,2,3,4,5,6,9,10,11,12,13,14,15],"sql-commands":[0,7,8,16]}, + "columnresolution": {"depends-on-command":[7,8,9,10,11,12,14,15,16,17,18,20,21,22,24,25,26,27,31,32,34,35,37,42,43,44,45,46,47,48,49,50,51],"sql-commands":[0,1,2,3,4,5,6,13,19,23,28,29,30,36,39,40,41,52,53,54]}, + "columnresolution-negative": {"depends-on-command":[8,9,10,11,12,14,15,16,17,18,21,22,23,25,30,35],"sql-commands":[0,1,2,3,4,5,7,13,20,24,26,27,28,29,31,32,33,34,36,37]}, + "columnresolution-views": {"depends-on-command":[9,10,11,12,13,14,15],"sql-commands":[8,16]}, "conditional-functions": {"conditional-physical":[5,6,8,9,13,14,15,16],"depends-on-command":[1,2,3,4,7,10],"sql-commands":[0,17]}, - "count": {"depends-on-command":[1,2,3,4,8,9,10,11,12,18],"legacy-configs":[14,16,20],"sql-commands":[0,13,15,17,19]}, + "count": {"depends-on-command":[1,2,3,4,8,9,10,11,12,18],"legacy-configs":[14,16,20],"sql-commands":[0]}, "cross-join": {"depends-on-command":[2,3,4,5,6,11,12],"sql-commands":[0,1,7,8,9,10]}, - "csv-functions": {"depends-on-command":[13],"fn-url-xml-csv":[0,1,2,3,4,5,6,7,8,9,10,11,15,16,17,18,19,20,21,22,33,34,35,36,37,38],"sql-commands":[12,14],"time-geo-types":[23,24,25,26,27,28,29,30,31,32]}, - "cte": {"analyzer-bugs":[50],"depends-on-command":[6,7,9,10,19,23,31,32,36,45,46,47,48],"fn-misc":[22],"query-features":[17,41,42,43],"sql-commands":[0,1,2,3,51,52,53,54],"subqueries":[27]}, - "cte-command": {"depends-on-command":[1,3,4,5,7,9,10,11],"sql-commands":[0,2,6,8,12,13]}, + "csv-functions": {"depends-on-command":[13],"fn-url-xml-csv":[0,1,2,3,4,5,6,7,8,9,10,11,15,16,17,18,19,20,21,22,33,34,35,36,37,38],"sql-commands":[12],"time-geo-types":[23,24,25,26,27,28,29,30,31,32]}, + "cte": {"analyzer-bugs":[24],"depends-on-command":[6,7,9,10,16,19,23,31,32,36,45,46,47,48],"fn-misc":[22],"query-features":[17,41,42,43],"sql-commands":[0,1,2,3,54],"subqueries":[27]}, + "cte-command": {"depends-on-command":[1,4,5,7,9,10,11],"sql-commands":[0,6,8,12,13]}, "cte-legacy": {"legacy-configs":[3,4,5,6,7,8,12,13,14,15,17,18,19,21]}, "cte-nested": {"query-features":[3,4,5]}, "cte-nonlegacy": {"legacy-configs":[3,4,5,6,8,12,13,14,15,17,18]}, - "cte-recursion": {"depends-on-command":[6,12,45,48,49,52,53,61,67],"query-features":[0,1,2,3,4,8,10,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,31,32,33,34,35,36,37,38,39,40,41,42,43,55,56,57,58,59,63,64,69,70,71,72,73,74,75,77,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100],"sql-commands":[5,7,11,13,30,44,46,47,50,51,54,60,62,65,66,68,76,78]}, + "cte-recursion": {"depends-on-command":[6,12,45,48,49,52,53,61,67],"query-features":[0,1,2,3,4,8,10,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,31,32,33,34,35,36,37,38,39,40,41,42,43,55,56,57,58,59,63,64,69,70,71,72,73,74,75,77,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100],"sql-commands":[5,7,11,13,44,46,47,50,51,54,60,62,65,66,68]}, "cte-with-multi-children-operators": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15],"sql-commands":[0,1]}, "current_database_catalog": {"fn-misc":[0]}, - "date": {"cast-matrix":[8,9],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99],"depends-on-command":[55,56,57,58,68,69],"fn-json":[76],"fn-url-xml-csv":[77],"nested-interval-types":[74],"sql-commands":[0]}, + "date": {"cast-matrix":[8,9],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99],"depends-on-command":[68,69],"fn-json":[76],"fn-url-xml-csv":[77],"nested-interval-types":[74]}, "datetime-formatting": {"datetime":[31,32,33],"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0]}, "datetime-formatting-invalid": {"datetime":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36]}, "datetime-formatting-legacy": {"datetime":[31,32,33],"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0]}, - "datetime-legacy": {"cast-matrix":[8,9,106,107,108],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99,102,109,110,111,112,113,114,115,116,117,118,119,120,121,122,125,126,127,128,129,130,131,134,136,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,161,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,213,214,215,216,217,219,220,221,222,225,226,227,228,231,232,233,234,237,238,239,240],"depends-on-command":[55,56,57,58,68,69,163,165,166,211,212],"fn-json":[76,223],"fn-url-xml-csv":[77,224],"nested-interval-types":[74,218],"sql-commands":[0,162,164,210],"time-geo-types":[123,124,132,133,135,137]}, + "datetime-legacy": {"cast-matrix":[8,9,106,107,108],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99,102,109,110,111,112,113,114,115,116,117,118,119,120,121,122,125,126,127,128,129,130,131,134,136,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,161,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,213,214,215,216,217,219,220,221,222,225,226,227,228,231,232,233,234,237,238,239,240],"depends-on-command":[68,69,163,165,166,211,212],"fn-json":[76,223],"fn-url-xml-csv":[77,224],"nested-interval-types":[74,218],"sql-commands":[162,164],"time-geo-types":[123,124,132,133,135,137]}, "datetime-parsing": {"datetime":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]}, "datetime-parsing-invalid": {"cast-matrix":[27],"datetime":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,23,24,25,26],"fn-url-xml-csv":[18]}, "datetime-parsing-legacy": {"datetime":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]}, "datetime-special": {"datetime":[1,2,3],"output-names":[0]}, - "decimalArithmeticOperations": {"depends-on-command":[1,2,3,6,7,30,31],"output-names":[13,21,37],"sql-commands":[0,4,5,29,54]}, + "decimalArithmeticOperations": {"depends-on-command":[6,7,30,31],"output-names":[13,21,37],"sql-commands":[4,5,54]}, "describe": {"depends-on-command":[42,43,44,45,46,47],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67]}, "describe-part-after-analyze": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]}, "describe-query": {"depends-on-command":[15],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,16,17,18]}, "describe-table-after-alter-table": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11]}, - "double-quoted-identifiers": {"nested-interval-types":[20,24],"query-features":[16],"sql-commands":[10,11,12,18,19,22,23]}, - "double-quoted-identifiers-enabled": {"depends-on-command":[27],"nested-interval-types":[24],"query-features":[7,16],"sql-commands":[1,2,3,10,11,12,19,22,23,25,26,28,29]}, - "except": {"depends-on-command":[2,3,4,5,6,7,8,10,11],"sql-commands":[0,1,9,12,13,14]}, - "except-all": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],"sql-commands":[0,1,2,3,23,24,25,26]}, + "double-quoted-identifiers": {"nested-interval-types":[20,24],"query-features":[16],"sql-commands":[10,11,12]}, + "double-quoted-identifiers-enabled": {"nested-interval-types":[24],"query-features":[7,16],"sql-commands":[1,2,3,10,11,12,25,28,29]}, + "except": {"depends-on-command":[2,3,4,5,6,7,8,10,11],"sql-commands":[0,1,9]}, + "except-all": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],"sql-commands":[0,1,2,3]}, "execute-immediate": {"depends-on-command":[19,29,32,34,37,39,42,44],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,20,21,22,23,24,25,26,27,28,30,31,33,35,36,38,40,41,43,45,46,47,48,49,50,51,52,55,56,57,58,59,60,62,63,64,65,66,67,68,69,70,71,72,73,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117]}, - "explain": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,18,19,20,21,22,29],"query-features":[17],"sql-commands":[0,1,2,3,4,5,23,24,25,26,27,28,30]}, - "explain-aqe": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,18,19,20,21,22,29],"query-features":[17],"sql-commands":[0,1,2,3,4,5,23,24,25,26,27,28,30]}, + "explain": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,18,19,20,21,22,29],"query-features":[17],"sql-commands":[0,1,2,3,4,23,24,25,26,27,28,30]}, + "explain-aqe": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,18,19,20,21,22,29],"query-features":[17],"sql-commands":[0,1,2,3,4,23,24,25,26,27,28,30]}, "explain-cbo": {"depends-on-command":[4],"sql-commands":[0,1,2,3,5,6]}, "extract": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,127],"nested-interval-types":[102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,128],"sql-commands":[0]}, "extract-value-nulltype-single-pass": {"nested-interval-types":[0]}, @@ -527,71 +522,71 @@ "generators": {"depends-on-command":[1,2,3,10,11,12,19,20,21,28,29,30,39,40,46,47],"fn-json":[51,52,53,54,55],"generators":[4,5,7,8,13,14,16,17,22,23,25,26,31,32,34,35,41,42,48,49,56,57,58,59,60],"nested-interval-types":[6,9,15,18,24,27,33,36,37,38,43,44,45,50],"sql-commands":[0]}, "generators-resolution-edge-cases": {"fn-array":[24,25,26,28],"generators":[0,1,2,3,4,5,10,11,12,13,27,29,32,33,34,35,44,45,46,47,48,49],"query-features":[6,7,8,9,14,15,16,17,18,19,20,21,22,23,36,37,38,39,40,41,42,43,50,51,52,53],"window":[30,31]}, "group-analytics": {"depends-on-command":[1,2,3,4,6,7,9,10,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51],"sql-commands":[0,5]}, - "group-by": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,18,20,34,35,36,37,38,39,40,41,48,49,50,51,52,53,54,55,56,57,58,60,61,81,96,97,98,99,100,101],"fn-aggregate":[42,43,44,45,46,47],"query-features":[16,24,25,26,27,29,30,31,59,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,82,83,84,85,86,87,88,89,90,91,92,93,94,95],"sql-commands":[0,1,17,19,28,32,33,102]}, - "group-by-alias": {"analyzer-bugs":[11],"depends-on-command":[1,2,3,4,5,6,8,9,10,12,13,14,15,16,17,18,20,22,24,34],"query-features":[21,23,26,27,28,29,35],"sql-commands":[0,30]}, + "group-by": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,18,20,34,35,36,37,38,39,40,41,48,49,50,51,52,53,54,55,56,57,58,60,61,81,96,97,98,99,100,101],"fn-aggregate":[42,43,44,45,46,47],"query-features":[16,24,25,26,27,29,30,31,59,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,82,83,84,85,86,87,88,89,90,91,92,93,94,95],"sql-commands":[0,1,17,33,102]}, + "group-by-alias": {"depends-on-command":[1,2,3,4,5,6,8,9,10,12,13,14,15,16,17,18,20,22,24,34],"query-features":[21,23,26,27,28,29,35],"sql-commands":[0]}, "group-by-all": {"depends-on-command":[1,2,3,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,28],"query-features":[4,27],"sql-commands":[0]}, "group-by-all-duckdb": {"depends-on-command":[1,2,3,4,5,6],"query-features":[7,8],"sql-commands":[0]}, "group-by-all-mosha": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10],"sql-commands":[0]}, "group-by-filter": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,69,70,71,72,73,74,75,76,77,78,79,80],"query-features":[68],"sql-commands":[0,1,2,3]}, - "group-by-ordinal": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,17,18,19,20,21,22,23,24,25,26,27,28,29,30,32,34],"query-features":[31],"sql-commands":[0,33]}, + "group-by-ordinal": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,17,18,19,20,21,22,23,24,25,26,27,28,29,30,32,34],"query-features":[31],"sql-commands":[0]}, "grouping_set": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,16,17,19,20,21,23,25,26,27,30,31,32,33,34,35,37,38,39,41,42,43,44,45],"query-features":[18,22,24,28,29],"sql-commands":[0,36,40]}, "grouping_set_grand_total_disabled": {"query-features":[0,1,2,3,4,5,6,7]}, "having": {"conditional-physical":[48],"depends-on-command":[1,2,3,4,14,15,16,17,18,19,20,21,22,23,28,29,30,31,32],"query-features":[5,6,7,8,9,10,11,12,13,24,25,26,27,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,49],"sql-commands":[0]}, "having-and-order-by-recursive-type-name-resolution": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44]}, "higher-order-functions": {"depends-on-command":[3,4,5,6,7,9,11,12,13,14,16,17,18,20,22,26,27,28,29,30,31],"hof":[1,2,23,24,34,35,36,38,39,40,42,43,44,46,47,48,50,51,52,54,55,56,58,59,60,62,63,64,66,67,68,70,71,72,74,75,76,78,79,80,82],"nested-interval-types":[8,10,15,19,21,37,41,45,49,53,57,61,65,69,73,77,81],"query-features":[32,33],"sql-commands":[0,25]}, "hll": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17],"fn-aggregate":[31,32,33],"query-features":[18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0,1,2,3,4,5,6,7,34,35,36]}, - "identifier-clause": {"depends-on-command":[1,2,3,4,5,6,7,15,16,17,18,22,23,24,40,52,80,83,84,85,86,87,88,90,91,92,93,94,102,103,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,134,138,140,142,145,150,151,177,180,183,215,216,220,221],"sql-commands":[0,8,9,10,11,12,13,14,19,20,21,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,81,82,89,95,96,97,98,99,100,101,104,105,106,107,108,109,110,111,112,113,114,115,116,133,135,136,137,139,141,143,144,146,147,148,149,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,178,179,181,182,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,217,218,219,222,223,224,225,226,228,229,232,236]}, - "identifier-clause-legacy": {"depends-on-command":[1,2,3,4,5,6,7,15,16,17,18,22,23,24,40,52,80,83,84,85,86,87,88,90,91,92,93,94,102,103,117,118,119,122,125,177,183],"sql-commands":[0,8,9,10,11,12,13,14,19,20,21,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,81,82,89,95,96,97,98,99,100,101,104,105,106,107,108,109,110,111,112,113,114,115,116,135,146,147,149,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,168,169,170,171,172,173,174,175,178,181,184,185,186,187,188,189,190,191,192,193,195,196,197,202,203,208,209,211,212,213,214,217,218,219,222,223,226,228,229,232,236]}, + "identifier-clause": {"depends-on-command":[1,2,3,4,5,6,7,15,16,17,18,22,23,24,40,52,80,83,84,85,86,87,88,90,91,92,93,94,102,103,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,134,138,140,142,145,150,151,177,180,183,215,216,220,221],"sql-commands":[8,9,10,11,12,13,14,19,20,21,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,81,82,89,95,96,97,98,99,100,101,104,105,106,107,108,109,110,111,112,113,114,115,116,133,136,137,139,141,143,144,146,147,148,149,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,178,179,181,182,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,217,218,219,222,223,224,225,226,228,229,232,236]}, + "identifier-clause-legacy": {"depends-on-command":[1,2,3,4,5,6,7,15,16,17,18,22,23,24,40,52,80,83,84,85,86,87,88,90,91,92,93,94,102,103,117,118,119,122,125,177,183],"sql-commands":[8,9,10,11,12,13,14,19,20,21,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,81,82,89,95,96,97,98,99,100,101,104,105,106,107,108,109,110,111,112,113,114,115,116,146,147,149,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,168,169,170,171,172,173,174,175,176,178,181,184,185,186,187,188,189,190,191,192,193,195,196,197,202,208,209,211,212,213,214,217,218,219,222,223,226,228,229,232,236]}, "ilike": {"fn-string":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]}, "ilike-all": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12],"sql-commands":[0]}, "ilike-any": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12],"sql-commands":[0]}, "inline-table": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,14,16,17,18,19,20,21,22,23,24,25,26]}, "inner-join": {"depends-on-command":[6],"sql-commands":[0,1,2,3,4,5]}, - "intersect-all": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,17,18,21,22],"sql-commands":[0,1,16,19,20,23,24,25]}, - "interval": {"datetime":[0,4,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86],"depends-on-command":[160,161,162,163],"nested-interval-types":[2,3,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,39,40,42,43,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,87,88,89,90,91,92,93,94,96,97,98,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,121,122,123,124,125,126,127,128,129,130,131,148,150,151,152,153,154,155,156,157,158,164,165,166,167,168,169,170,171,172,173,174,175,176,177,179,189,190,191,192,202,203,204,205,206,209,210,211,212,215,216,217,218,219,220,221,222,223,224,225,226,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285],"query-features":[184,185,186],"sql-commands":[159]}, + "intersect-all": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,17,18,21,22],"sql-commands":[0,1,20]}, + "interval": {"datetime":[0,4,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86],"depends-on-command":[160,161,162,163],"nested-interval-types":[2,3,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,39,40,42,43,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,87,88,89,90,91,92,93,94,96,97,98,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,121,122,123,124,125,126,127,128,129,130,131,148,150,151,152,153,154,155,156,157,158,164,165,166,167,168,169,170,171,172,173,174,175,176,177,179,189,190,191,192,202,203,204,205,206,209,210,211,212,215,216,217,218,219,220,221,222,223,224,225,226,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285],"query-features":[184,185,186]}, "join-empty-relation": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],"sql-commands":[0,1,2]}, "join-lateral": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,19,20,21,22,23,25,26,27,28,29,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,105,106,107,108,110,111,112,113,114,115,116,118,119,120,121,122,125,126,127,128,129,130,131,133,134,135,136,138,139,140,141,142,143,144,145,146,147,148],"query-features":[24,30,104,109,124,149,150,151,152,153],"sql-commands":[0,1,2,3,117,123,132,137,154,155,156,157]}, - "join-nearest-by": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,22,25],"sql-commands":[0,1,21,23,24,26,27,28]}, + "join-nearest-by": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,22,25],"sql-commands":[0,1,24,26,27,28]}, "join-resolution-edge-cases": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12],"sql-commands":[0,1,13,14]}, - "json-functions": {"depends-on-command":[20,46],"fn-json":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,21,22,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,73,74,75,76,77,78,79,80,94,95,96,97,98,99,100,101,102,103,104,105],"sql-commands":[19,23,45,72],"time-geo-types":[81,82,83,84,85,86,87,88,89,90,91,92,93]}, + "json-functions": {"depends-on-command":[20,46],"fn-json":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,21,22,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,73,74,75,76,77,78,79,80,94,95,96,97,98,99,100,101,102,103,104,105],"sql-commands":[19,45],"time-geo-types":[81,82,83,84,85,86,87,88,89,90,91,92,93]}, "keywords": {"query-features":[0,1]}, "keywords-enforced": {"query-features":[0,1]}, "kllquantiles": {"depends-on-command":[12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,68,69,70,71,72,73,74,75,76,77,78,82,83,84,85,92,93,94,95,96,97,98,99,100,101],"fn-aggregate":[36,37,67,79,80,81,86,87,88,89,90,91],"query-features":[33,34,35],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,102,103,104,105,106,107]}, "like-all": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12],"sql-commands":[0]}, "like-any": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12],"sql-commands":[0]}, - "limit": {"analyzer-bugs":[9],"nested-interval-types":[1,2],"parser-tail":[6],"query-features":[12]}, + "limit": {"nested-interval-types":[1,2],"parser-tail":[6],"query-features":[12]}, "linear-regression": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"sql-commands":[0]}, "listagg": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,21,41,42,43,44,45,46,47],"query-features":[18,19,20,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,48,49,50],"sql-commands":[0,1]}, "listagg-collations": {"parser-pipe-collate":[0,1,3,4,5,6,7,8,10,12,14],"query-features":[2,9,11,13]}, - "literals": {"datetime":[36,45,52],"fn-array":[48],"fn-map":[47],"fn-struct":[49],"legacy-configs":[59,60],"nested-interval-types":[46],"output-names":[20,21,26,39,43],"sql-commands":[58]}, + "literals": {"datetime":[36,45,52],"fn-array":[48],"fn-map":[47],"fn-struct":[49],"legacy-configs":[59,60],"nested-interval-types":[46],"output-names":[20,21,26,39,43]}, "map": {"fn-array":[0],"fn-map":[2,3,4,5,6,7,8,9],"nested-interval-types":[1]}, "mask-functions": {"fn-string":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,29,30,31,32,33,34,35,36,37,38,39,40,41,42,55,56],"query-features":[15,16,17,18,19,20,21,22,23,24,25,26,27,28,43,44,45,46,47,48,49,50,51,52,53,54]}, "math": {"fn-string":[56,57,58,59,60,61,62,63,64,65]}, "max-min-by-k": {"depends-on-command":[1,2,3,4,5,6,8,9,11,12,14,15,17,18,20,21,22,23,24,25],"sql-commands":[0,7,10,13,16,19,26,27,28,29,30,31]}, "metadata_column_resolution": {"depends-on-command":[5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53],"sql-commands":[0,1,2,3,4,54,55,56,57]}, - "misc-functions": {"datetime":[4],"depends-on-command":[15],"fn-misc":[0,1,2,3,5,6,7,8,9,10,11,12,14,16,17,18,19,20],"query-features":[25],"sql-commands":[13,21,24]}, + "misc-functions": {"datetime":[4],"depends-on-command":[15],"fn-misc":[0,1,2,3,5,6,7,8,9,10,11,12,14,16,17,18,19,20],"query-features":[25],"sql-commands":[13]}, "mode": {"depends-on-command":[1,2,3,14,15,16,17,18,19,20,21,22,23,24,26,27],"query-features":[4,5,6,7,8,9,10,11,12,13],"sql-commands":[0,25]}, "name-precedence-in-order-by-and-having-with-conflicting-attributes": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"query-features":[18,19,39,40],"sql-commands":[0,1,44,45]}, "named-function-arguments": {"depends-on-command":[5,6,7,26],"fn-string":[33],"query-features":[0,1,2,3,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,27,28,29,30,31,32],"sql-commands":[4,25]}, "natural-join": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"query-features":[31,32,33],"sql-commands":[0,1,2,3]}, - "non-excludable-rule": {"query-features":[1,3,5],"sql-commands":[0,2,4]}, - "nonansi/array": {"depends-on-command":[1,2,3,5,6,7,8,11],"fn-array":[9,10,12,13,14,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,59,60,63,64,65,66,67,68,69,70,71,74,76,77,78,79,80,83,85,86,87],"fn-string":[15,16,17,18,19,20,21],"nested-interval-types":[22,23,52,72,73,75,81,82,84],"query-features":[62],"sql-commands":[0,4,58,61]}, + "non-excludable-rule": {"query-features":[1,3,5]}, + "nonansi/array": {"depends-on-command":[1,2,3,5,6,7,8,11],"fn-array":[9,10,12,13,14,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,59,60,63,64,65,66,67,68,69,70,71,74,76,77,78,79,80,83,85,86,87],"fn-string":[15,16,17,18,19,20,21],"nested-interval-types":[22,23,52,72,73,75,81,82,84],"query-features":[62],"sql-commands":[0,4]}, "nonansi/cast": {"cast-matrix":[58,59,60,66,67,70,71,130,131],"fn-string":[28,29,30,31,32,33,34,35,36,124,125],"nested-interval-types":[39,40,41,43,44,72,73,74,75,76,77,78,79,80,81,82,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,126,127,132,133,134,135,143],"query-features":[83,87],"sql-commands":[37,38],"time-geo-types":[104,105,106,107,108,109,110,111,112,113,114,115,116,136,137,138,139,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163]}, "nonansi/conditional-functions": {"conditional-physical":[5,6,8,9,13,14,15,16],"depends-on-command":[1,2,3,4,7,10],"sql-commands":[0,17]}, - "nonansi/date": {"cast-matrix":[8,9],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99],"datetime-bugs":[37,50],"depends-on-command":[55,56,57,58,68,69],"fn-json":[76],"fn-url-xml-csv":[77],"nested-interval-types":[74],"sql-commands":[0]}, + "nonansi/date": {"cast-matrix":[8,9],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99],"depends-on-command":[55,56,68,69],"fn-json":[76],"fn-url-xml-csv":[77],"nested-interval-types":[74]}, "nonansi/datetime-parsing-invalid": {"cast-matrix":[27],"datetime":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,23,24,25,26],"fn-url-xml-csv":[18]}, "nonansi/datetime-special": {"datetime":[1,2,3],"output-names":[0]}, - "nonansi/decimalArithmeticOperations": {"depends-on-command":[1,2,3,6,7,30,31],"output-names":[13,21,37,45],"sql-commands":[0,4,5,29,54]}, - "nonansi/double-quoted-identifiers": {"nested-interval-types":[20,24],"query-features":[16],"sql-commands":[10,11,12,18,19,22,23]}, + "nonansi/decimalArithmeticOperations": {"depends-on-command":[6,7,30,31],"output-names":[13,21,37,45],"sql-commands":[4,5,54]}, + "nonansi/double-quoted-identifiers": {"nested-interval-types":[20,24],"query-features":[16],"sql-commands":[10,11,12]}, "nonansi/higher-order-functions": {"depends-on-command":[3,4,5,6,7,9,11,12,13,14,16,17,18,20,22,26,27,28,29,30,31],"hof":[1,2,23,24,34,35,36,38,39,40,42,43,44,46,47,48,50,51,52,54,55,56,58,59,60,62,63,64,66,67,68,70,71,72,74,75,76,78,79,80,82],"nested-interval-types":[8,10,15,19,21,37,41,45,49,53,57,61,65,69,73,77,81],"query-features":[32,33],"sql-commands":[0,25]}, - "nonansi/interval": {"datetime":[0,4,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86],"depends-on-command":[160,161,162,163],"nested-interval-types":[2,3,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,39,40,42,43,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,87,88,89,90,91,92,93,94,96,97,98,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,121,122,123,124,125,126,127,128,129,130,131,148,150,151,152,153,154,155,156,157,158,164,165,166,167,168,169,170,171,172,173,174,175,176,177,179,189,190,191,192,202,203,204,205,206,209,210,211,212,215,216,217,218,219,220,221,222,223,224,225,226,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285],"query-features":[184,185,186],"sql-commands":[159]}, + "nonansi/interval": {"datetime":[0,4,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86],"depends-on-command":[160,161,162,163],"nested-interval-types":[2,3,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,39,40,42,43,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,87,88,89,90,91,92,93,94,96,97,98,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,121,122,123,124,125,126,127,128,129,130,131,148,150,151,152,153,154,155,156,157,158,164,165,166,167,168,169,170,171,172,173,174,175,176,177,179,189,190,191,192,202,203,204,205,206,209,210,211,212,215,216,217,218,219,220,221,222,223,224,225,226,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285],"query-features":[184,185,186]}, "nonansi/keywords": {"query-features":[0,1]}, - "nonansi/literals": {"datetime":[36,45,52],"fn-array":[48],"fn-map":[47],"fn-struct":[49],"legacy-configs":[59,60],"nested-interval-types":[46],"output-names":[20,21,26,39,43],"sql-commands":[58]}, + "nonansi/literals": {"datetime":[36,45,52],"fn-array":[48],"fn-map":[47],"fn-struct":[49],"legacy-configs":[59,60],"nested-interval-types":[46],"output-names":[20,21,26,39,43]}, "nonansi/map": {"fn-array":[0],"fn-map":[2,3,4,5,6,7,8,9],"nested-interval-types":[1]}, "nonansi/math": {"fn-string":[56,57,58,59,60,61,62,63,64,65]}, "nonansi/parse-schema-string": {"fn-json":[2,3],"fn-url-xml-csv":[0,1]}, - "nonansi/string-functions": {"depends-on-command":[218],"fn-misc":[5],"fn-number-format":[173,174,175,176,177,178,179,180,181],"fn-regex":[13,14,15,16,17,18,19,20,21,22,23,24,25,26],"fn-string":[0,1,6,7,8,9,10,11,12,27,28,29,30,31,32,33,34,35,36,60,61,62,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,98,101,103,106,109,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,130,133,136,139,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252],"output-names":[4,38,39,41,42,43,44,45,47,48,51,52,53,54,55,56,57,58,63,64],"query-features":[37,99,102,104,107,110,128,131,134,137,140],"sql-commands":[97,100,105,108,129,132,135,138,217,219]}, - "nonansi/timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62,108],"time-geo-types":[21,22,30,31,33,35]}, + "nonansi/string-functions": {"depends-on-command":[218],"fn-misc":[5],"fn-number-format":[173,174,175,176,177,178,179,180,181],"fn-regex":[13,14,15,16,17,18,19,20,21,22,23,24,25,26],"fn-string":[0,1,6,7,8,9,10,11,12,27,28,29,30,31,32,33,34,35,36,60,61,62,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,98,101,103,106,109,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,130,133,136,139,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252],"output-names":[4,38,39,41,42,43,44,45,47,48,51,52,53,54,55,56,57,58,63,64],"query-features":[37,99,102,104,107,110,128,131,134,137,140],"sql-commands":[217]}, + "nonansi/timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62],"time-geo-types":[21,22,30,31,33,35]}, "nonansi/try_aggregates": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31]}, "nonansi/try_arithmetic": {"cast-matrix":[2,32,43,58],"coercion":[3,33,44,59],"datetime":[11,12,17,18],"nested-interval-types":[13,14,15,16,19,20,21,22,23,24,25,35,36,37,38,39,40,52,53,54,55,67,68,69,70,71,72],"query-features":[10,34,51,66]}, "nonansi/try_datetime_functions": {"datetime":[0,1,2,3,4,5]}, @@ -599,20 +594,20 @@ "null-handling": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29],"sql-commands":[0,1,2,3,4,5,6,7,30]}, "null-propagation": {"query-features":[0,1,2,3]}, "operators": {"fn-string":[57,60,65,66,67,68,69,70,71,72,73,74,75,76],"output-names":[32,33,34,35,36,37,38,39,40,41,42,43,46,48,50,51,52,53,54,55,62]}, - "order-by": {"depends-on-command":[1,2,3,4,7,8,9,10,11,15,16,17,18,19,20,21,22,23,24,25,26,27],"query-features":[5,6,12,13,28,29,30,31,32,33,34,35],"sql-commands":[0,36],"variant-type":[14]}, + "order-by": {"depends-on-command":[1,2,3,4,7,8,9,10,11,15,16,17,18,19,20,21,22,23,24,25,26,27],"query-features":[5,6,12,13,28,29,30,31,32,33,34,35],"sql-commands":[0],"variant-type":[14]}, "order-by-alias": {"depends-on-command":[1,2,3,4,5,6,7,9,10,11,12],"query-features":[14,15,16,17],"sql-commands":[0]}, "order-by-all": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14],"query-features":[15,16,17],"sql-commands":[0]}, - "order-by-and-having-on-top-of-aggregate-with-join": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145],"sql-commands":[0,1,146,147]}, + "order-by-and-having-on-top-of-aggregate-with-join": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145],"sql-commands":[0,1]}, "order-by-nulls-ordering": {"depends-on-command":[2,3,4,5,6,7,8,9,13,14,15],"sql-commands":[0,1,10,11,12,16]}, - "order-by-ordinal": {"depends-on-command":[1,2,3,4,5,6,7,8,10,11,12,13,14,15,16,18,19,20,21,22,23,24,26,27],"sql-commands":[0,9,17,25]}, + "order-by-ordinal": {"depends-on-command":[1,2,3,4,5,6,7,8,10,11,12,13,14,15,16,18,19,20,21,22,23,24,26,27],"sql-commands":[0]}, "outer-join": {"depends-on-command":[2,5],"sql-commands":[0,1,3,4]}, - "parameterless-function-name-precedence": {"depends-on-command":[2,3,5,7,13],"fn-misc":[9,10],"sql-commands":[0,1,6,8,14,15]}, - "parameterless-function-name-precedence-legacy": {"depends-on-command":[2,3,5,7,13],"fn-misc":[9,10],"sql-commands":[0,1,6,8,14,15]}, - "parse-query-correctness": {"depends-on-command":[1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,38,40,42,46,48,50,52,54,56,58,60,62,64],"sql-commands":[0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,37,39,41,43,44,45,47,49,51,53,55,65]}, - "parse-query-correctness-old-behavior": {"depends-on-command":[1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,38,40,42,46,48,50,52,54,56,58,60,62,64],"sql-commands":[0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,37,39,41,43,44,45,47,49,51,53,55,65]}, + "parameterless-function-name-precedence": {"depends-on-command":[13],"fn-misc":[9,10],"sql-commands":[6,8]}, + "parameterless-function-name-precedence-legacy": {"depends-on-command":[13],"fn-misc":[9,10],"sql-commands":[6,8]}, + "parse-query-correctness": {"depends-on-command":[38,40,42,46,48,50,52,54,56,58,60,62,64],"sql-commands":[37,39,41,43,44,45,47,49,51,53,55,65]}, + "parse-query-correctness-old-behavior": {"depends-on-command":[1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,38,40,42,46,48,50,52,54,56,58,60,62,64],"sql-commands":[37,39,41,43,44,45,47,49,51,53,55,65]}, "parse-schema-string": {"fn-json":[2,3],"fn-url-xml-csv":[0,1]}, - "percentiles": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,38,39,40,41,42,43,44],"query-features":[45,46,47,48,50,51],"sql-commands":[0,1,35,49,52]}, - "pipe-operators": {"depends-on-command":[25,26,27,28,29,30,31,32,33,34,37,38,39,41,42,43,44,45,47,48,49,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,88,89,92,93,94,95,96,99,100,101,103,105,106,107,110,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,184,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,205,206,207,208,209,210,211,212,214,215,216,217,218,219,220,233,234,235,238,241,242,244,245,246,247,248,250,251,252,254,256,257,258,259,260,261,262,263,264,265,266,267,268,269,277,281,282,283,284,285,287,288,290,292,296,300,301,302,303,304,305,307,308,310,311,312,313],"parser-pipe-collate":[35,40,46,50,90,91,97,98,102,104,166,204,221,222,223,224,225,226,227,228,229,230,231,232,236,237,239,240,243,255,270,271,272,273,274,275,276,278,279,280,286,298,306,309],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,289,291,293,294,295,299,314,315,316]}, + "percentiles": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,38,39,40,41,42,43,44],"query-features":[45,46,47,48,50,51],"sql-commands":[0,1,35]}, + "pipe-operators": {"depends-on-command":[25,26,27,28,29,30,31,32,33,34,37,38,39,41,42,43,44,45,47,48,49,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,88,89,92,93,94,95,96,99,100,101,103,105,106,107,110,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,184,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,205,206,207,208,209,210,211,212,214,215,216,217,218,219,220,233,234,235,238,241,242,244,245,246,247,248,250,251,252,254,256,257,258,259,260,261,262,263,264,265,266,267,268,269,277,281,282,283,284,285,287,288,290,292,296,300,301,302,303,304,305,307,308,310,311,312,313],"parser-pipe-collate":[35,40,46,50,90,91,97,98,102,104,166,204,221,222,223,224,225,226,227,228,229,230,231,232,236,237,239,240,243,255,270,271,272,273,274,275,276,278,279,280,286,298,306,309],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,289,294,314,315,316]}, "pivot": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"sql-commands":[0,1,2]}, "postgreSQL/aggregates_part1": {"depends-on-command":[45,46,47,48],"fn-aggregate":[9,10,11,12,13,14,15,16,17,18,35,36,37,38,39,40,41,42,43],"query-features":[19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"sql-commands":[44,49],"subqueries":[54,55]}, "postgreSQL/aggregates_part2": {"depends-on-command":[2,3,4,5,6,7,8,12,13,14,15],"generators":[27],"sql-commands":[0,1,11]}, @@ -630,28 +625,28 @@ "postgreSQL/int4": {"cast-matrix":[39,40,41,42,46,47,48,49],"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"query-features":[50,51],"sql-commands":[0,1,2,3,4,5,52]}, "postgreSQL/int8": {"cast-matrix":[62,63,64,69,71,72,77,78,79,80,81,82,83,84,85,86,87],"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,65,66,67,68,70,73],"query-features":[74,75,76,88,89],"sql-commands":[0,1,2,3,4,5,90]}, "postgreSQL/interval": {"nested-interval-types":[0,1,2,3,4,5,6,7,8,9,10,11,14,17]}, - "postgreSQL/join": {"conditional-physical":[134,135],"depends-on-command":[28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,65,66,67,68,69,70,71,72,73,74,75,76,79,80,81,82,83,84,85,86,87,88,89,91,92,93,94,95,96,105,106,110,113,116,120,122,126,127,128,129,133,136,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,160,161,162,163,166,167,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,196],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,55,56,57,58,59,60,61,62,63,64,77,78,98,99,100,101,102,103,104,108,109,111,112,114,115,117,118,119,121,124,125,130,131,132,137,138,139,158,159,164,165,168,191,192,193,194,195,197,198]}, - "postgreSQL/limit": {"depends-on-command":[9,10],"fn-string":[12],"query-features":[3,4,5,6,7],"sql-commands":[8,11]}, + "postgreSQL/join": {"conditional-physical":[134,135],"depends-on-command":[28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,65,66,67,68,69,70,71,72,73,74,75,76,79,80,81,82,83,84,85,86,87,88,89,91,92,93,94,95,96,105,106,110,113,116,120,122,126,127,128,129,133,136,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,160,161,162,163,166,167,169,170,171,172,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,196],"sql-commands":[0,1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,55,56,57,58,59,60,61,62,63,64,77,78,98,99,100,101,102,103,104,108,109,111,112,114,115,117,118,119,121,124,125,130,131,132,137,138,139,158,159,164,165,168,191,192,193,194,195,197,198]}, + "postgreSQL/limit": {"depends-on-command":[9,10],"fn-string":[12],"sql-commands":[8,11]}, "postgreSQL/numeric": {"cast-matrix":[507,508,509,510,511,512],"depends-on-command":[460,463,466,469,472,475,478,481,484,487,490,493,496,497,505,521,533,538,539,540,541,542,558],"fn-number-format":[543,544,545,546,547,548,549,550,551],"fn-string":[523,524,525,526,527,528,529,530,534,535,536],"output-names":[561,563,564,565,569,570,571,572,573,574,575,579,585,586,587,588,589,590,591,592],"query-features":[576,577,578,593,594],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,461,462,464,465,467,468,470,471,473,474,476,477,479,480,482,483,485,486,488,489,491,492,494,495,498,499,500,501,502,503,504,506,513,514,515,516,517,518,519,520,522,531,532,537,552,553,554,555,556,557,595,596,597,598,599,600,601,602,603,604,605]}, - "postgreSQL/select": {"depends-on-command":[9,10,11,18,20,21,22,23,24,25,26,27,28,29,30,31,32],"query-features":[16,17,34,35],"sql-commands":[0,1,12,19,36]}, - "postgreSQL/select_distinct": {"depends-on-command":[1,2,3,4,7,8,9,10],"sql-commands":[0,6]}, + "postgreSQL/select": {"depends-on-command":[18,20,21,22,23,24],"query-features":[16,17,34,35],"sql-commands":[1,12,19,36]}, + "postgreSQL/select_distinct": {"depends-on-command":[7,8,9,10],"sql-commands":[6]}, "postgreSQL/select_having": {"depends-on-command":[11,12,13,14,15,16,17,18,19,20],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,21]}, "postgreSQL/select_implicit": {"depends-on-command":[11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,37]}, "postgreSQL/strings": {"cast-matrix":[2,3,4,5,6,7,70,86,87,88,89,90,91,92,93,94,95,96,97,98,99,119,120,121,122],"depends-on-command":[76,77],"fn-string":[14,15,16,17,18,19,79,80,84,85,100,111,112,113,114,115,116,117,118],"output-names":[102,104,107,109],"sql-commands":[71,72,73,74,75,123]}, "postgreSQL/text": {"cast-matrix":[0,1,7],"datetime":[11],"depends-on-command":[5],"fn-array":[17],"fn-string":[12,13,14,15,16,20,21,22,23,26,27,28,31,32,33,34,35,36,37,38,39,40],"query-features":[18],"sql-commands":[2,3,4,19,41]}, "postgreSQL/timestamp": {"datetime":[25,28],"depends-on-command":[8,9,10,17,18,19,20,21,22,23,24,26,27],"sql-commands":[0,1,2,3,4,5,6,7,11,12,13,14,15,16,29]}, "postgreSQL/union": {"cast-matrix":[13,15,17,68],"depends-on-command":[20,21,22,23,24,25,26,27,28,29,30,31,32,41,42,43,44,45,46,47,48,49,50,51,52,69,70,71],"query-features":[53,54,55,56,57,58,59,60,61,62,63,64,67],"sql-commands":[0,1,2]}, - "postgreSQL/window_part1": {"depends-on-command":[27,39],"sql-commands":[0,26,38,40,41,42],"window":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,28,29,30,31,32,33,34,35,36,37]}, + "postgreSQL/window_part1": {"depends-on-command":[27,39],"sql-commands":[26,38,40,42],"window":[12,13,14,15,32,33,34,35,36,37]}, "postgreSQL/window_part2": {"depends-on-command":[17,18,19,20,21,22,23,24,25,26,27,28],"query-features":[9,10,11,12,13,14],"sql-commands":[0,1,15,16,29,30],"window":[2,3,4,5,6,7,8]}, - "postgreSQL/window_part3": {"depends-on-command":[9,12,13,14,15,17,18,19,21,22,24],"sql-commands":[0,1,2,3,4,10,11,27,28,29],"window":[5,6,7,8,16,25,26]}, + "postgreSQL/window_part3": {"depends-on-command":[12,13,14,15,17,18,19,21,22,24],"sql-commands":[1,2,3,4,10,11,27,28,29],"window":[5,6,7,8,26]}, "postgreSQL/window_part4": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38]}, - "postgreSQL/with": {"depends-on-command":[5,7,12,23,24,25,26,32,34,38,39,40,43,44,45,46,47,59,60,61,68,69,70,71,72,73,81,86,87,88,89,92,93,97,99,100],"fn-string":[1],"query-features":[2,3,8,9,10,13,28,35,51,52,53,54,55,56,62,63,64,65,66,67,75,78,79],"sql-commands":[4,6,14,15,16,17,18,19,20,21,22,27,29,31,33,36,37,41,42,48,49,50,57,58,80,82,83,84,85,90,91,94,95,98,101,102,103,104,105,106,107,108,109,110]}, + "postgreSQL/with": {"depends-on-command":[5,7,12,23,24,25,26,32,34,38,39,40,43,44,45,46,47,59,60,61,68,69,70,71,72,73,81,86,87,88,89,92,93,97,99,100],"fn-string":[1],"query-features":[2,3,8,9,10,13,28,35,51,52,53,54,55,56,62,63,64,65,66,67,75,78,79],"sql-commands":[4,6,14,15,16,17,18,19,20,21,22,31,33,36,37,41,42,48,49,50,57,58,80,82,83,84,85,90,91,94,95,98,101,102,103,104,105,106,107,108,109,110]}, "pred-pushdown": {"depends-on-command":[2,3],"sql-commands":[0,1]}, - "predicate-functions": {"datetime":[30,31,37,38,44,45,51,52,53,54,55,56,57,80,86],"fn-string":[81,87],"sql-commands":[88,94]}, + "predicate-functions": {"datetime":[30,31,37,38,44,45,51,52,53,54,55,56,57,80,86],"fn-string":[81,87]}, "qualify": {"depends-on-command":[1,2,4,5,6,7,8],"sql-commands":[0,3]}, - "query_regex_column": {"depends-on-command":[3,4,5,6,7,8,10,11,12,13,14,15,16,17,18,19,20,21,24,25,26,27,28,29,30,31,32,33],"sql-commands":[0,1,2,9,22,23]}, + "query_regex_column": {"depends-on-command":[3,4,5,6,7,8,10,11,12,13,14,15,16,17,18,19,20,21,24,25,26,27,28,29,30,31,32,33],"sql-commands":[1,2,23]}, "random": {"fn-string":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,61,62,63,64,65,66,67,70,71],"query-features":[25,41,42,60,68,69,72,73]}, - "regexp-functions": {"fn-regex":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67],"query-features":[31,68]}, + "regexp-functions": {"fn-regex":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,32,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67],"query-features":[31,68]}, "replacing-missing-expression-with-alias": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]}, "runtime-replaceable-edge-cases": {"fn-url-xml-csv":[0]}, "scripting/randomly_generated_scripts": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124]}, @@ -659,23 +654,23 @@ "session-variable-precedence": {"depends-on-command":[3,4,5,6],"sql-commands":[0,1,2,7,8,9]}, "show-create-table": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49]}, "show-tables": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,15,17,18,19,20,21,22,23,24,25,26]}, - "show-tblproperties": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12]}, + "show-tblproperties": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,11]}, "show-views": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]}, "show_columns": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]}, "sql-compatibility-functions": {"cast-matrix":[8,9,10,11],"conditional-physical":[0,1,2,3,4,5,6,7],"depends-on-command":[13],"query-features":[14],"sql-commands":[12]}, "sql-on-files": {"depends-on-command":[4,9,14,19],"files":[2,7,12,17],"object-stores":[22],"sql-commands":[0,1,5,6,10,11,15,16,20,21]}, - "sql-path": {"depends-on-command":[38,42,47,49,64,66,81,82,87,103,104,108,113],"fn-misc":[0,2,4,6,9,11,14,18,21,23,26,27,125,131,137],"sql-commands":[1,3,5,7,8,10,12,13,15,16,17,19,20,22,24,25,28,29,30,31,32,33,34,35,36,37,39,40,41,43,44,45,46,48,50,51,53,54,55,56,57,58,59,60,61,62,63,65,67,69,70,71,72,73,74,75,76,77,78,79,80,83,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,105,106,107,109,110,111,112,114,115,116,117,118,119,120,121,122,123,124,126,127,128,129,130,132,133,134,135,136,138]}, - "sql-session-variables": {"depends-on-command":[4,6,10,12,15,21,32,34,36,38,40,42,44,46,60,63,79,81,83,85,87,89,91,93,104,106,108,110,112,114,120,127,129,134,144,148,166,168,170,172,174,189,194,197,200,203,206,209,212,234,235,236,237,241,242,243,244,245,246,247,248,250,251,252,254,264],"sql-commands":[0,1,2,3,5,7,8,9,11,13,14,16,18,19,20,22,24,25,26,29,30,31,33,35,37,39,41,43,45,47,48,49,50,51,52,53,54,55,56,57,58,59,61,62,64,66,67,68,69,70,75,76,77,78,80,82,84,86,88,90,92,94,95,96,97,98,99,100,101,102,103,105,107,109,111,113,115,116,117,118,119,121,122,123,124,125,126,128,130,131,132,133,135,136,137,138,139,140,141,142,143,145,146,147,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,167,169,171,173,175,176,177,178,179,180,181,182,183,184,185,186,187,188,190,191,192,193,195,196,198,199,201,202,204,205,207,208,210,211,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,238,239,240,253,255,256,257,258,259,260,261,262,263,265]}, - "sql-udf": {"depends-on-command":[1,2,4,5,7,9,11,13,17,19,21,23,25,29,30,31,35,39,41,43,44,54,56,66,68,70,72,74,76,78,79,80,82,83,84,86,87,88,90,91,92,94,95,96,98,99,100,102,103,104,106,107,108,111,112,114,115,117,119,120,121,123,124,126,127,129,130,132,133,134,136,137,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,205,206,207,209,211,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,295,296,297,298,299,300,303,304,305,306,307,309,310,312,314,315,317,319,324,326,330,336,337,338,342,343,344,349,350,351,352,354,355,356,357,406,407,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428],"sql-commands":[0,3,6,8,10,12,14,15,16,18,20,22,24,26,27,28,32,33,34,36,37,38,40,42,45,46,47,48,49,50,51,53,55,57,58,60,61,62,63,64,65,67,69,71,73,75,77,81,85,89,93,97,101,105,109,110,113,118,122,125,128,131,135,138,139,141,143,145,147,149,151,153,155,157,159,161,163,165,167,169,171,173,175,177,179,181,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,208,210,212,213,214,215,216,217,218,219,220,221,222,223,224,225,301,302,308,311,313,316,318,320,321,322,323,325,327,328,329,331,332,333,334,335,339,340,341,345,346,347,348,353,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,408,409,410,411,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569]}, - "sql-udf-name-precedence": {"depends-on-command":[2,4,6,8,10,14,16,18,20,23,25],"sql-commands":[0,1,3,5,7,9,11,13,15,17,19,21,22,24,26,27,28,29,30,31,32,33,34,35,36,37,38,39]}, - "sql-udf-name-precedence-legacy": {"depends-on-command":[2,4,6,8,10,12,14,16,18,20,23,25],"sql-commands":[0,1,3,5,7,9,11,13,15,17,19,21,22,24,26,27,28,29,30,31,32,33,34,35,36,37,38,39]}, + "sql-path": {"depends-on-command":[38,42,47,49,64,66,81,82,87,103,104,108,113],"fn-misc":[0,2,4,6,9,11,14,18,21,23,26,27,125,131,137],"sql-commands":[1,3,5,7,8,10,12,13,15,16,17,19,20,22,24,25,28,29,30,31,32,33,34,35,36,37,39,40,41,43,44,45,46,48,50,51,53,54,55,56,57,58,59,60,61,62,63,65,67,69,70,71,72,73,74,75,76,77,78,79,80,83,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,105,106,107,109,110,111,112,114,115,116,117,118,119,120,121,122,124,126,129,130,133,134,135,138]}, + "sql-session-variables": {"depends-on-command":[4,6,10,12,15,21,32,34,36,38,40,42,44,46,60,63,79,81,83,85,87,89,91,93,104,106,108,110,112,114,120,127,129,134,144,148,166,168,170,172,174,189,194,197,200,203,206,209,212,234,235,236,237,241,242,243,244,245,246,247,248,250,251,252,254,264],"sql-commands":[1,2,3,5,7,8,9,11,13,14,16,18,19,20,22,24,25,26,29,30,31,33,35,37,39,41,43,45,47,48,49,50,51,52,53,54,55,56,57,58,59,61,62,64,66,67,68,69,70,75,76,77,78,80,82,84,86,88,90,92,94,95,96,97,98,99,100,101,102,103,105,107,109,111,113,115,116,117,118,119,121,122,123,124,125,126,128,130,131,132,133,135,136,137,138,139,140,141,142,143,145,146,147,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,167,169,171,173,176,177,178,179,180,181,182,183,184,185,186,187,188,190,191,192,193,195,196,198,199,201,202,204,205,207,208,210,211,213,214,215,216,217,218,219,220,221,226,227,228,229,230,231,232,233,238,239,240,253,255,256,257,258,259,261,262,263,265]}, + "sql-udf": {"depends-on-command":[1,2,4,5,7,9,11,13,17,19,21,23,25,29,30,31,35,39,41,43,44,54,56,66,68,70,72,74,76,78,79,80,82,83,84,86,87,88,90,91,92,94,95,96,98,99,100,102,103,104,106,107,108,111,112,114,115,117,119,120,121,123,124,126,127,129,130,132,133,134,136,137,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,205,206,207,209,211,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,295,296,297,298,299,300,303,304,305,306,307,309,310,312,314,315,317,319,324,326,330,336,337,338,342,343,344,349,350,351,352,354,355,356,357,406,407,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428],"sql-commands":[0,3,6,8,10,12,14,15,16,18,20,22,24,26,27,28,32,33,34,36,37,38,40,42,45,46,47,48,49,50,51,53,55,57,58,60,61,62,63,64,65,67,69,71,73,75,77,81,85,89,93,97,101,105,109,110,113,118,122,125,128,131,135,138,139,141,143,145,147,149,151,153,155,157,159,161,163,165,167,169,171,173,175,177,179,181,183,184,185,186,187,188,189,190,191,192,193,194,202,203,204,208,210,212,213,214,215,216,217,218,219,220,221,222,223,224,225,301,302,308,311,313,316,318,320,321,322,323,325,327,328,329,332,333,334,339,340,341,345,346,347,348,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,408,409,410,411,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569]}, + "sql-udf-name-precedence": {"depends-on-command":[2,4,6,8,10,14,16,18,20,23,25],"sql-commands":[1,3,5,7,9,11,13,15,17,19,21,22,24,26,28,29,30,31,32,33,34,35,36,37,38,39]}, + "sql-udf-name-precedence-legacy": {"depends-on-command":[2,4,6,8,10,12,14,16,18,20,23,25],"sql-commands":[1,3,5,7,9,11,13,15,17,19,21,22,24,26,28,29,30,31,32,33,34,35,36,37,38,39]}, "st-functions": {"depends-on-command":[16,17,18,19,20,21,22,23,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,58,59,69,70,71,72,73,84,85,86,87,88,89,90,91,92,96,97,102,103,104,105],"sql-commands":[0,1,2,106],"time-geo-types":[3,4,5,6,7,8,9,10,11,12,13,14,15,24,25,26,27,28,29,30,31,32,33,34,53,54,55,56,57,60,61,62,63,64,65,66,67,68,74,75,76,77,78,79,80,81,82,83,93,94,95,98,99,100,101]}, - "string-functions": {"depends-on-command":[218],"fn-misc":[5],"fn-number-format":[173,174,175,176,177,178,179,180,181],"fn-regex":[13,14,15,16,17,18,19,20,21,22,23,24,25,26],"fn-string":[0,1,6,7,8,9,10,11,12,27,28,29,30,31,32,33,34,35,36,60,61,62,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,98,101,103,106,109,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,130,133,136,139,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252],"output-names":[4,38,39,41,42,43,44,45,47,48,51,52,53,54,55,56,57,58],"query-features":[37,99,102,104,107,110,128,131,134,137,140],"sql-commands":[97,100,105,108,129,132,135,138,217,219]}, + "string-functions": {"depends-on-command":[218],"fn-misc":[5],"fn-number-format":[173,174,175,176,177,178,179,180,181],"fn-regex":[13,14,15,16,17,18,19,20,21,22,23,24,25,26],"fn-string":[0,1,6,7,8,9,10,11,12,27,28,29,30,31,32,33,34,35,36,60,61,62,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,98,101,103,106,109,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,130,133,136,139,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252],"output-names":[4,38,39,41,42,43,44,45,47,48,51,52,53,54,55,56,57,58],"query-features":[37,99,102,104,107,110,128,131,134,137,140],"sql-commands":[217]}, "struct": {"depends-on-command":[3,4,5,6,7,8],"nested-interval-types":[1,2,9,11,13],"query-features":[10,12],"sql-commands":[0]}, - "subexp-elimination": {"depends-on-command":[1,2,3,4,5,6,7,8],"sql-commands":[0,9]}, + "subexp-elimination": {"depends-on-command":[1,2,3,4,5,6,7,8],"sql-commands":[0]}, "subquery/exists-subquery/exists-aggregate": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],"sql-commands":[0,1,2]}, "subquery/exists-subquery/exists-basic": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12],"sql-commands":[0,1,2]}, - "subquery/exists-subquery/exists-count-bug": {"depends-on-command":[3,4,5,6,7,8,9,11,12,13,14,15,16],"sql-commands":[0,1,2,10,17]}, + "subquery/exists-subquery/exists-count-bug": {"depends-on-command":[3,4,5,6,7,8,9,11,12,13,14,15,16],"sql-commands":[0,1,2]}, "subquery/exists-subquery/exists-cte": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2]}, "subquery/exists-subquery/exists-having": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2]}, "subquery/exists-subquery/exists-in-join-condition": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48],"sql-commands":[0,1,2]}, @@ -684,14 +679,14 @@ "subquery/exists-subquery/exists-outside-filter": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14],"sql-commands":[0,1,2]}, "subquery/exists-subquery/exists-within-and-or": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2]}, "subquery/in-subquery/in-basic": {"depends-on-command":[3,4,5,6],"sql-commands":[0,1,2]}, - "subquery/in-subquery/in-count-bug": {"depends-on-command":[3,4,5,6,7,8,9,10,11,13,14,15,16,17,18,19],"sql-commands":[0,1,2,12,20]}, + "subquery/in-subquery/in-count-bug": {"depends-on-command":[3,4,5,6,7,8,9,10,11,13,14,15,16,17,18,19],"sql-commands":[0,1,2]}, "subquery/in-subquery/in-group-by": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26],"sql-commands":[0,1,2]}, "subquery/in-subquery/in-having": {"depends-on-command":[3,4,5,6,7,8,9,10,11],"sql-commands":[0,1,2]}, "subquery/in-subquery/in-joins": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0,1,2,3,4,5,31,32,33]}, - "subquery/in-subquery/in-limit": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36],"sql-commands":[0,1,2,35,37]}, + "subquery/in-subquery/in-limit": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36],"sql-commands":[0,1,2]}, "subquery/in-subquery/in-multiple-columns": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2]}, - "subquery/in-subquery/in-null-semantics": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17,19,20,23,24,25,26,27,28],"sql-commands":[0,1,2,3,4,5,6,7,18,21,22,29,30,31,32,33]}, - "subquery/in-subquery/in-nullability": {"depends-on-command":[3,4,5,6,7,8],"sql-commands":[0,1,2]}, + "subquery/in-subquery/in-null-semantics": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17,19,20,23,24,25,26,27,28],"sql-commands":[0,2,3,4,5,6,31,32,33]}, + "subquery/in-subquery/in-nullability": {"depends-on-command":[4,6,7,8]}, "subquery/in-subquery/in-order-by": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],"sql-commands":[0,1,2]}, "subquery/in-subquery/in-set-operations": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27],"sql-commands":[0,1,2]}, "subquery/in-subquery/in-subquery-in-join-condition": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44],"sql-commands":[0,1,2]}, @@ -707,30 +702,30 @@ "subquery/negative-cases/invalid-correlation": {"depends-on-command":[3,4,5,6,7,9],"sql-commands":[0,1,2,8]}, "subquery/negative-cases/subq-input-typecheck": {"depends-on-command":[5,6,7,8,9],"sql-commands":[0,1,2,3,4]}, "subquery/resolution-edge-cases": {"depends-on-command":[3,4,5,6,7,8,9],"sql-commands":[0,1,2,10,11,12]}, - "subquery/scalar-subquery/nested-scalar-subquery-count-bug": {"depends-on-command":[5,6,7,8],"sql-commands":[0,1,2,3,4,9,10,11,12,13]}, - "subquery/scalar-subquery/scalar-subquery-count-bug": {"depends-on-command":[2,3,4,5,6,7,8,10,11,12,13,14,15,17,18,19],"sql-commands":[0,1,9,16,20]}, - "subquery/scalar-subquery/scalar-subquery-group-by": {"depends-on-command":[3,4,5,6,7,8,9,11,12,13,15,16,17,18,19,22],"sql-commands":[0,1,2,10,14,20,21,23]}, + "subquery/scalar-subquery/nested-scalar-subquery-count-bug": {"depends-on-command":[5,6,7,8],"sql-commands":[0,1,2,11,12,13]}, + "subquery/scalar-subquery/scalar-subquery-count-bug": {"depends-on-command":[2,3,4,5,6,7,8,10,11,12,13,14,15,17,18,19],"sql-commands":[0,1]}, + "subquery/scalar-subquery/scalar-subquery-group-by": {"depends-on-command":[3,4,5,6,7,8,9,11,12,13,15,16,17,18,19,22],"sql-commands":[0,1,2]}, "subquery/scalar-subquery/scalar-subquery-predicate": {"depends-on-command":[2,3,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59],"sql-commands":[0,1,4,5,6,39,40,41]}, - "subquery/scalar-subquery/scalar-subquery-select": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,19,20,21,22,23,24,25,31,32,33,34,35,36,37,38,42,43,44,45,46,47,48],"sql-commands":[0,1,2,17,18,27,28,29,30,39,41],"subqueries":[40]}, + "subquery/scalar-subquery/scalar-subquery-select": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,19,20,21,22,23,24,25,31,32,33,34,35,36,37,38,42,43,44,45,46,47,48],"sql-commands":[0,1,2,17,18,27,28,29,30],"subqueries":[40]}, "subquery/scalar-subquery/scalar-subquery-set-op": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58],"sql-commands":[0,1,2]}, - "subquery/subquery-nested-data": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,26],"sql-commands":[0,1,2,3,4,5,25,27,28,29]}, + "subquery/subquery-nested-data": {"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,26],"sql-commands":[0,1,2,3,4,5,28,29]}, "subquery/subquery-offset": {"depends-on-command":[6,7,8,9,10,11,12,13,16,17,18,19],"sql-commands":[0,1,2,3,4,5,14,15,20,21]}, "table-aliases": {"depends-on-command":[1,2,12,13,14,15],"sql-commands":[0,10,11]}, "table-valued-functions": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72]}, "tablesample-negative": {"depends-on-command":[3,4],"sql-commands":[0,1,2,5]}, "thetasketch": {"depends-on-command":[18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,80,81,82,83,84,85,86,87,88],"fn-aggregate":[101,102,103,104,105,106],"query-features":[67,68,69,70,71,72,73,74,75,76,77,78,79,89,90,91,92,93,94,95,96,97,98,99,100],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,107,108,109,110,111,112,113,114,115]}, - "time": {"cast-matrix":[145,146,147],"datetime":[4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,139,141,220,221,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,265,271,277,278,280,282],"depends-on-command":[5,142,143,144,222,223,224,225,226,227,228],"sql-commands":[0,1,2],"time-geo-types":[3,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,140,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,229,230,231,232,233,234,235,260,261,262,263,264,266,267,268,269,270,272,273,274,275,276,279,281,283]}, - "time-bucket": {"datetime":[13,27],"nested-interval-types":[1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,17,20,21,24,25,26,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64],"query-features":[18,19,22,23,65,66,67,69,70,71,72,73],"sql-commands":[0,68]}, - "timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62,108],"time-geo-types":[21,22,30,31,33,35]}, + "time": {"cast-matrix":[145,146,147],"datetime":[4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,139,141,220,221,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,265,271,277,278,280,282],"depends-on-command":[5,142,143,144,222,223,224,225,226,227,228],"sql-commands":[0,2],"time-geo-types":[3,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,140,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,229,230,231,232,233,234,235,260,261,262,263,264,266,267,268,269,270,272,273,274,275,276,279,281,283]}, + "time-bucket": {"datetime":[13,27],"nested-interval-types":[1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,17,20,21,24,25,26,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64],"query-features":[18,19,22,23,65,66,67,69,70,71,72,73]}, + "timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62],"time-geo-types":[21,22,30,31,33,35]}, "timestamp-ltz": {"datetime":[0,1,2,3,4,5,6,7,9,10,11,12,13,14,15,17,18,19,20,21],"time-geo-types":[8,16]}, "timestamp-ntz": {"datetime":[0,1,2,3,4,5,6,7,9,10,11,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28],"depends-on-command":[32],"sql-commands":[29,30,31,33],"time-geo-types":[8,13,15]}, "timestampNTZ/datetime-special": {"datetime":[1,2,3],"output-names":[0]}, "timestampNTZ/datetime-special-ansi": {"datetime":[1,2,3],"output-names":[0]}, - "timestampNTZ/timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62,108],"time-geo-types":[21,22,30,31,33,35]}, - "timestampNTZ/timestamp-ansi": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62,108],"time-geo-types":[21,22,30,31,33,35]}, - "timezone": {"depends-on-command":[13],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,14]}, + "timestampNTZ/timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62],"time-geo-types":[21,22,30,31,33,35]}, + "timestampNTZ/timestamp-ansi": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62],"time-geo-types":[21,22,30,31,33,35]}, + "timezone": {"depends-on-command":[13],"sql-commands":[0,3,4,5,6,7,8,9,10,11,12,14]}, "to_from_avro": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2,8,9]}, - "transform": {"depends-on-command":[3,4,5,6,7,8,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,39,41,43,44,45,49,50,51],"parser-tail":[9,38],"sql-commands":[0,1,2,11,12,37,40,42]}, + "transform": {"depends-on-command":[3,4,5,6,7,8,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,39,41,43,44,45,49,50,51],"parser-tail":[9,38],"sql-commands":[0,1,2,11,12,37]}, "try-string-functions": {"fn-string":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34]}, "try_aggregates": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31]}, "try_arithmetic": {"cast-matrix":[2,32,43,58],"datetime":[11,12,17,18],"nested-interval-types":[13,14,15,16,19,20,21,22,23,24,25,35,36,37,38,39,40,52,53,54,55,67,68,69,70,71,72],"query-features":[10,34,51,66]}, @@ -741,57 +736,56 @@ "tuplesketch": {"depends-on-command":[20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,152,153,154,155,156,157,158,159,162,163,164,165,166,167,168,169,170,171,172,173,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,195,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,260,262,273,274,275,276,277,279,280,282,283,285,286,287,288,289,290],"fn-aggregate":[174,252,253,254,255,256,257,261,263,270,271,272,278,281,284],"query-features":[120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,160,161,190,191,192,193,194,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,258,259,264,265,266,267,268,269],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,291,292,293,294,295,296,297,298,299,300]}, "type-coercion-edge-cases": {"depends-on-command":[1,2],"parser-tail":[3],"sql-commands":[0,4]}, "typeCoercion/native/arrayJoin": {"datetime":[9],"fn-array":[0,1,2,3,4,5,6,7,8,10]}, - "typeCoercion/native/binaryComparison": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264],"sql-commands":[0]}, - "typeCoercion/native/booleanEquality": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96],"sql-commands":[0]}, - "typeCoercion/native/caseWhenCoercion": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144],"sql-commands":[0]}, - "typeCoercion/native/concat": {"depends-on-command":[12,13],"query-features":[0,1,2,4,5,6,8,9,10],"sql-commands":[3,7,11]}, - "typeCoercion/native/dateTimeOperations": {"nested-interval-types":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39],"sql-commands":[0]}, - "typeCoercion/native/decimalPrecision": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144],"sql-commands":[0]}, - "typeCoercion/native/division": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144],"sql-commands":[0]}, - "typeCoercion/native/elt": {"query-features":[0,1,3,5],"sql-commands":[2,4]}, - "typeCoercion/native/ifCoercion": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144],"sql-commands":[0]}, - "typeCoercion/native/implicitTypeCasts": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46],"sql-commands":[0]}, - "typeCoercion/native/inConversion": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288],"sql-commands":[0]}, + "typeCoercion/native/binaryComparison": {"depends-on-command":[193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,253,254,255,256,257,258]}, + "typeCoercion/native/booleanEquality": {"depends-on-command":[8,10,20,22,32,34,44,46,56,58,68,70,80,82,92,94]}, + "typeCoercion/native/caseWhenCoercion": {"depends-on-command":[93,94,95,104,105,116,118,128,131,132,143]}, + "typeCoercion/native/concat": {"depends-on-command":[12,13],"query-features":[0,1,2,4,5,6,8,9,10],"sql-commands":[11]}, + "typeCoercion/native/dateTimeOperations": {"nested-interval-types":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39]}, + "typeCoercion/native/decimalPrecision": {"depends-on-command":[33,34,35,36,37,38,39,40,81,82,83,84,85,86,87,88,121,122,123,124,125,126,127,128,169,170,171,172,173,174,175,176]}, + "typeCoercion/native/elt": {"query-features":[0,1,3,5]}, + "typeCoercion/native/ifCoercion": {"depends-on-command":[1,2,3,4,5,6,7,8,13,14,15,16,17,18,19,20,25,26,27,28,29,30,31,32,37,38,39,40,41,42,43,44,49,50,51,52,53,54,55,56,61,62,63,64,65,66,67,68,73,74,75,76,77,78,79,80,85,86,87,88,89,90,91,92,93,94,95,96,104,105,116,118,128,131,132,140,143,144]}, + "typeCoercion/native/implicitTypeCasts": {"depends-on-command":[21,22,31,32,33,34,35,39,40,41,43,46]}, + "typeCoercion/native/inConversion": {"depends-on-command":[93,94,95,104,105,116,118,128,131,132,143,237,238,239,248,249,260,262,272,275,276,287]}, "typeCoercion/native/mapZipWith": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18],"sql-commands":[0]}, "typeCoercion/native/mapconcat": {"depends-on-command":[1,2,3,4,5,6,7],"sql-commands":[0]}, - "typeCoercion/native/promoteStrings": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315],"sql-commands":[0]}, - "typeCoercion/native/stringCastAndExpressions": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,28,29,30,31],"fn-string":[27],"sql-commands":[0]}, - "typeCoercion/native/widenSetOperationTypes": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144],"sql-commands":[0]}, - "typeCoercion/native/windowFrameCoercion": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24],"sql-commands":[0]}, + "typeCoercion/native/promoteStrings": {"depends-on-command":[11,12,23,24,82,83,93,94,147,148,149,158,159,160,170,171,172,181,182,183,193,194,195,205,206,207,217,218,219,229,230,231,241,242,243,253,254,255,265,266,267,277,278,279,289,290,291,301,302,303,308,309,312,313,314,315]}, + "typeCoercion/native/stringCastAndExpressions": {"depends-on-command":[8,9,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,28,29,30,31],"fn-string":[27]}, + "typeCoercion/native/widenSetOperationTypes": {"depends-on-command":[93,94,95,104,105,116,118,128,131,132,143]}, + "typeCoercion/native/windowFrameCoercion": {"depends-on-command":[9,10,11,13,14,15,16,17,18,19,20,21,22,23,24]}, "udaf/udaf": {"depends-on-command":[2,3,5],"sql-commands":[0,1,4,6,7]}, "udaf/udaf-group-analytics": {"depends-on-command":[1,2,3,4,6,7,9,10,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38],"sql-commands":[0,5]}, - "udaf/udaf-group-by": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,18,20,21,22,23,27,28,29,30,31,32,33],"sql-commands":[0,17,19,26],"test-udfs":[13,24,25]}, - "udaf/udaf-group-by-ordinal": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,28],"sql-commands":[0,27],"test-udfs":[11,12]}, + "udaf/udaf-group-by": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,18,20,21,22,23,27,28,29,30,31,32,33],"sql-commands":[0,17,26],"test-udfs":[13,24,25]}, + "udaf/udaf-group-by-ordinal": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,28],"sql-commands":[0],"test-udfs":[11,12]}, "udaf/udaf-grouping-set": {"depends-on-command":[1,2,3,4,5,6,7,8,11,12,13,14],"sql-commands":[0]}, "udf/postgreSQL/udf-aggregates_part1": {"depends-on-command":[44,45,46,47],"sql-commands":[43,48],"test-udfs":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,49,50,51,52,53,54,55]}, "udf/postgreSQL/udf-aggregates_part2": {"depends-on-command":[2,3,4,8,9,10,11],"sql-commands":[0,1,7],"test-udfs":[12,13,14,15,16,17,18,19,20,21,22,23,24]}, "udf/postgreSQL/udf-aggregates_part3": {"test-udfs":[0,1]}, "udf/postgreSQL/udf-aggregates_part4": {"test-udfs":[0,1,2,3]}, "udf/postgreSQL/udf-case": {"depends-on-command":[21,22,23,24,25,26,27,28,29,30],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,32,33],"test-udfs":[12,13,14,15,16,17,18,19,20,31]}, - "udf/postgreSQL/udf-join": {"depends-on-command":[28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,65,66,67,68,69,70,71,72,73,74,75,76,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,105,106,107,114,117,120,124,126,127,130,131,132,133,137,140,144,145,146,147,148,149,150,151,152,153,154,155,158,159,160,161,164,165,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,194],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,55,56,57,58,59,60,61,62,63,64,77,78,98,99,100,101,102,103,104,108,109,110,111,112,113,115,116,118,119,121,122,123,125,128,129,134,135,136,141,142,143,156,157,162,163,166,189,190,191,192,193,195,196],"test-udfs":[138,139]}, + "udf/postgreSQL/udf-join": {"depends-on-command":[28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,65,66,67,68,69,70,71,72,73,74,75,76,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,105,106,107,114,117,120,124,126,127,130,131,132,133,137,140,144,145,146,147,148,149,150,151,152,153,154,155,158,159,160,161,164,165,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,194],"sql-commands":[0,1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,55,56,57,58,59,60,61,62,63,64,77,78,98,99,100,101,102,103,104,108,109,110,111,112,113,115,116,118,119,121,122,123,125,128,129,134,135,136,141,142,143,156,157,162,163,166,189,190,191,192,193,195,196],"test-udfs":[138,139]}, "udf/postgreSQL/udf-select_having": {"depends-on-command":[11,12,13,14,15,16,17,18,19,20],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,21]}, "udf/postgreSQL/udf-select_implicit": {"depends-on-command":[11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,37]}, "udf/udf-count": {"depends-on-command":[1,2,3,4],"sql-commands":[0]}, "udf/udf-cross-join": {"depends-on-command":[2,3,4,5,6,11,12],"sql-commands":[0,1,7,8,9,10]}, "udf/udf-except": {"depends-on-command":[2,3,4,5,6,7,8],"sql-commands":[0,1]}, - "udf/udf-except-all": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],"sql-commands":[0,1,2,3,23,24,25,26]}, + "udf/udf-except-all": {"depends-on-command":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],"sql-commands":[0,1,2,3]}, "udf/udf-group-analytics": {"depends-on-command":[1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28],"sql-commands":[0,5]}, - "udf/udf-group-by": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,15,16,17,19,21,22,23,24,31,32,33,34,35,36,37,38,43,44,45,46,47,48,49,50,51],"sql-commands":[0,18,20,30],"test-udfs":[14,25,26,27,28,29,39,40,41,42]}, + "udf/udf-group-by": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,15,16,17,19,21,22,23,24,31,32,33,34,35,36,37,38,43,44,45,46,47,48,49,50,51],"sql-commands":[0,18,30],"test-udfs":[14,25,26,27,28,29,39,40,41,42]}, "udf/udf-having": {"depends-on-command":[1,2,3],"sql-commands":[0],"test-udfs":[4]}, "udf/udf-inline-table": {"test-udfs":[0,1,2,3,4,5,6,7,8,9,10,12,14,15,16]}, "udf/udf-inner-join": {"depends-on-command":[6],"sql-commands":[0,1,2,3,4,5]}, - "udf/udf-intersect-all": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,17,18],"sql-commands":[0,1,16,19,20,21]}, + "udf/udf-intersect-all": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,17,18],"sql-commands":[0,1]}, "udf/udf-join-empty-relation": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],"sql-commands":[0,1,2]}, "udf/udf-natural-join": {"depends-on-command":[2,3,4,5],"sql-commands":[0,1]}, - "udf/udf-outer-join": {"depends-on-command":[2,6],"sql-commands":[0,1,3,4,5,7]}, + "udf/udf-outer-join": {"depends-on-command":[2,6],"sql-commands":[0,1,3,4]}, "udf/udf-pivot": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29],"sql-commands":[0,1,2]}, "udf/udf-special-values": {"test-udfs":[0,1,2,3,4,5]}, "udf/udf-udaf": {"depends-on-command":[2,3,5],"sql-commands":[0,1,4,6,7]}, - "udf/udf-union": {"depends-on-command":[2,3,8],"sql-commands":[0,1,5,6,7,11,12,13,14,15],"test-udfs":[4,9,10]}, + "udf/udf-union": {"depends-on-command":[2,3,8],"sql-commands":[0,1,5,6,7],"test-udfs":[4,9,10]}, "udf/udf-window": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,17,18,19,20,21,22],"sql-commands":[0]}, - "udtf/udtf": {"depends-on-command":[9,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,30,31,32,33,34,35,36,37,38,39,40,41,42,59,60,68],"sql-commands":[0,1,2,3,71,72],"test-udfs":[4,5,6,7,8,11,12,54,56,57,58,63,64,65,66,67,69,70]}, - "union": {"depends-on-command":[3,4,9,13,14,15],"fn-array":[11],"fn-map":[10],"sql-commands":[0,1,2,6,7,8,12,16,17,18,19,20,21,22]}, - "union-per-child-output-deduplication": {"depends-on-command":[4,5,6,7,8,9,10,11],"sql-commands":[0,1,2,3,12,13]}, + "udtf/udtf": {"depends-on-command":[9,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,30,31,32,33,34,35,36,37,38,39,40,41,42,59,60,68],"sql-commands":[2,3,71,72],"test-udfs":[4,5,6,7,8,11,12,54,56,57,58,63,64,65,66,67,69,70]}, + "union": {"depends-on-command":[3,4,9,13,14,15],"fn-array":[11],"fn-map":[10],"sql-commands":[0,1,2,6,7,8,12,22]}, + "union-per-child-output-deduplication": {"depends-on-command":[4,5,6,7,8,9,10,11],"sql-commands":[0,2,3,12,13]}, "union-resolution-edge-cases": {"depends-on-command":[2,3,5,6,7,8,9],"sql-commands":[0,1,10,11]}, "unpivot": {"depends-on-command":[1,2,3,5,6,7],"sql-commands":[0,4]}, "url-functions": {"fn-url-xml-csv":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]}, @@ -801,15 +795,15 @@ "vector-agg": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]}, "vector-distance": {"fn-misc":[0,1,2,3,4,5,6,7,8,9,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41],"nested-interval-types":[11,12]}, "vector-norm": {"fn-misc":[0,1,2,3,4,5,6,7,8,9,10,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45],"nested-interval-types":[11,12,13,14]}, - "view-conf": {"depends-on-command":[4,8],"sql-commands":[0,1,2,3,5,6,7,9,10]}, - "view-schema-binding": {"depends-on-command":[3,7,12,16,22,28],"sql-commands":[0,1,2,4,5,6,8,9,10,11,13,14,15,17,18,19,20,21,23,24,25,26,27,29,30,31]}, - "view-schema-binding-config": {"depends-on-command":[18,23,31,37,44,50,56,59,62,68,72,76],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,24,25,26,27,28,29,30,32,33,34,35,36,38,39,40,41,42,43,45,46,47,48,49,51,52,53,54,55,57,58,60,61,63,64,65,66,67,69,70,71,73,74,75,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101]}, - "view-schema-compensation": {"depends-on-command":[4,9,14,17,20,26,30,34,44,47],"sql-commands":[0,1,2,3,5,6,7,8,10,11,12,13,15,16,18,19,21,22,23,24,25,27,28,29,31,32,33,35,36,37,38,39,40,41,42,43,45,46,48,49]}, - "view-schema-evolution": {"depends-on-command":[4,9,14,20,24,30,35,40,46,50,54,64,70,76,83,86,96],"sql-commands":[0,1,2,3,5,6,7,8,10,11,12,13,15,16,17,18,19,21,22,23,25,26,27,28,29,31,32,33,34,36,37,38,39,41,42,43,44,45,47,48,49,51,52,53,55,56,57,58,59,60,61,62,63,65,66,67,68,69,71,72,73,74,75,77,78,79,80,81,82,84,85,87,88,89,90,91,92,93,94,95,97,98,99]}, - "view-schema-type-evolution": {"depends-on-command":[4,9,14,20,24,28,36,42,51,54],"sql-commands":[0,1,2,3,5,6,7,8,10,11,12,13,15,16,17,18,19,21,22,23,25,26,27,29,30,31,32,33,34,35,37,38,39,40,41,43,44,45,46,47,48,49,50,52,53,55,56,57]}, - "view-with-default-collation": {"depends-on-command":[2,5,11,12,18,19,25,26,29,30,31,32,37,38,39,40,41,42,46,47,49,56,57,58,61,64,70,71,77,78,84,85,88,89,90,91,96,97,98,99,100,101,105,106,108,115,116,117],"sql-commands":[0,1,3,4,6,7,8,9,10,13,14,15,16,17,20,21,22,23,24,27,28,33,34,35,36,43,44,45,48,50,51,52,53,54,55,59,60,62,63,65,66,67,68,69,72,73,74,75,76,79,80,81,82,83,86,87,92,93,94,95,102,103,104,107,109,110,111,112,113,114,118,119]}, + "view-conf": {"depends-on-command":[4,8],"sql-commands":[0,2,6]}, + "view-schema-binding": {"depends-on-command":[3,7,12,16,22,28],"sql-commands":[0,1,2,4,5,6,8,9,10,11,13,14,15,17,19,20,21,23,24,25,26,27,29,31]}, + "view-schema-binding-config": {"depends-on-command":[18,23,31,37,44,50,56,59,62,68,72,76],"sql-commands":[0,2,3,4,5,6,7,8,9,12,13,15,16,17,19,20,21,22,24,28,29,30,32,33,34,35,36,38,39,41,42,43,45,46,47,48,49,51,52,53,54,55,57,58,60,61,63,64,65,66,67,69,70,71,73,74,75,77,80,82,83,84,86,87,88,94,95,97,98,101]}, + "view-schema-compensation": {"depends-on-command":[4,9,14,17,20,26,30,34,44,47],"sql-commands":[1,2,3,5,6,7,8,10,11,12,13,15,16,18,19,21,22,23,24,25,27,28,29,31,32,33,35,36,37,38,39,40,41,42,43,45,46,49]}, + "view-schema-evolution": {"depends-on-command":[4,9,14,20,24,30,35,40,46,50,54,64,70,76,83,86,96],"sql-commands":[0,1,2,3,5,6,7,8,10,11,12,13,15,16,17,18,19,21,22,23,25,26,27,28,29,31,32,33,34,36,37,38,39,41,42,43,44,45,47,48,49,51,52,53,55,56,57,58,59,60,61,62,63,65,66,67,68,69,71,72,73,74,75,77,78,79,80,81,82,84,85,87,88,89,90,91,92,93,94,95,97,99]}, + "view-schema-type-evolution": {"depends-on-command":[4,9,14,20,24,28,36,42,51,54],"sql-commands":[0,1,2,3,5,6,7,8,10,11,12,13,15,16,17,18,19,21,22,23,25,26,27,29,30,31,32,33,34,35,37,38,39,40,41,43,44,45,46,47,48,49,50,52,53,55,57]}, + "view-with-default-collation": {"depends-on-command":[2,5,11,12,18,19,25,26,29,30,31,32,37,38,39,40,41,42,46,47,49,56,57,58,61,64,70,71,77,78,84,85,88,89,90,91,96,97,98,99,100,101,105,106,108,115,116,117],"sql-commands":[1,4,7,8,9,10,14,15,16,17,21,22,23,24,28,33,34,35,36,44,45,48,51,52,53,54,55,60,63,66,67,68,69,73,74,75,76,80,81,82,83,87,92,93,94,95,103,104,107,110,111,112,113,114,119]}, "window": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,26,27,28,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,49,50,51,52,53,54,55,56,57,58,59,61,62,63,64,65,66,67,68,69,70],"query-features":[29],"sql-commands":[0,1,2,60]}, "window-with-aggregates": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]}, - "xml-functions": {"depends-on-command":[30],"fn-url-xml-csv":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,15,16,17,18,19,20,21,22,23,24,25,26,27,28,32,33,34,35,36,37,38,39,50,51,52,53,54,55],"sql-commands":[14,29,31],"time-geo-types":[40,41,42,43,44,45,46,47,48,49]} + "xml-functions": {"depends-on-command":[30],"fn-url-xml-csv":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,15,16,17,18,19,20,21,22,23,24,25,26,27,28,32,33,34,35,36,37,38,39,50,51,52,53,54,55],"sql-commands":[29],"time-geo-types":[40,41,42,43,44,45,46,47,48,49]} } } From 96b2a24f3b24e2bf57a0801cabbe1d78b5147ee1 Mon Sep 17 00:00:00 2001 From: techysneha14 <343708768+shehatathe@users.noreply.github.com> Date: Sat, 24 Oct 2026 21:55:20 +0200 Subject: [PATCH 8/8] tests: re-record the Spark 4.2 golden baseline after the merged P2a work (421 statements now pass) Signed-off-by: techysneha14 <343708768+shehatathe@users.noreply.github.com> --- tests/spark-golden/known-failures.json | 107 +++++++++---------------- 1 file changed, 37 insertions(+), 70 deletions(-) diff --git a/tests/spark-golden/known-failures.json b/tests/spark-golden/known-failures.json index 9d9d167b1..6cd0f1bec 100644 --- a/tests/spark-golden/known-failures.json +++ b/tests/spark-golden/known-failures.json @@ -15,11 +15,6 @@ "summary": "full Spark type coercion (implicit string casts with ANSI off)", "task": "P2-T071d" }, - "conditional-physical": { - "kind": "bug", - "owner": "physical planner follow-up of P2-T074", - "summary": "coalesce/if/nvl/nvl2/nullif/ifnull/zeroifnull/nullifzero resolve but are not bound in physical plans" - }, "datetime": { "kind": "unsupported", "summary": "datetime functions and literals beyond P2a (TIMESTAMP literals, date/timestamp arithmetic, patterns, unit-argument forms)", @@ -45,11 +40,6 @@ "summary": "array and collection functions", "task": "P2-T028" }, - "fn-bitwise-predicate": { - "kind": "unsupported", - "summary": "bitwise and predicate functions", - "task": "P2-T037" - }, "fn-json": { "kind": "unsupported", "summary": "JSON functions", @@ -65,11 +55,6 @@ "summary": "misc functions (typeof, uuid, rand, raise_error, vector, current_*)", "task": "P2-T035" }, - "fn-number-format": { - "kind": "unsupported", - "summary": "number formatting: to_number, to_char, format_number", - "task": "P2-T039" - }, "fn-regex": { "kind": "unsupported", "summary": "regular-expression functions and operators", @@ -262,10 +247,6 @@ "detail": "^parse failed", "query": "(?i)\\b(transform|identifier|tablesample|nearest)\\b|\\btable\\s*\\(|:\\w" }, - { - "category": "conditional-physical", - "detail": "The feature the expression (coalesce|if|nvl|nvl2|nullif|ifnull|zeroifnull|nullifzero)\\(" - }, { "category": "fn-string", "detail": "The feature the operator ilike" @@ -346,10 +327,6 @@ "category": "fn-aggregate", "detail": "The feature WITHIN GROUP" }, - { - "category": "fn-number-format", - "detail": "(The feature function |Cannot resolve routine `)(?i)(to_number|try_to_number|to_char|to_varchar|format_number)\\b" - }, { "category": "fn-regex", "detail": "(The feature function |Cannot resolve routine `)(?i)(regexp\\w*|rlike|split)\\b" @@ -427,14 +404,6 @@ "lambda" ] }, - { - "category": "fn-bitwise-predicate", - "family": [ - "bitwise", - "predicate", - "operators" - ] - }, { "category": "fn-url-xml-csv", "family": [ @@ -469,10 +438,10 @@ "binary_basic": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, "binary_hex": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, "binary_hex_discrete": {"cast-matrix":[2],"fn-array":[3],"fn-url-xml-csv":[4,5,6,7]}, - "bitwise": {"depends-on-command":[21,22,23,24,25,26],"fn-bitwise-predicate":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,27,28,29,30,31,32,33,34,43,44,45],"nested-interval-types":[40,41,42],"sql-commands":[20]}, - "cast": {"cast-matrix":[58,59,60,66,67,70,71,130,131],"fn-string":[28,29,30,31,32,33,34,35,36,124,125],"nested-interval-types":[39,40,41,43,44,72,73,74,75,76,77,78,79,80,81,82,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,126,127,132,133,134,135,143],"query-features":[83,87],"sql-commands":[37,38],"time-geo-types":[104,105,106,107,108,109,110,111,112,113,114,115,116,136,137,138,139,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163]}, + "bitwise": {"depends-on-command":[21,22,23,24,25,26],"nested-interval-types":[40,41,42],"sql-commands":[20]}, + "cast": {"cast-matrix":[58,59,60,66,67,70,71,130,131],"fn-string":[28,124],"nested-interval-types":[39,40,41,43,44,72,73,74,75,76,77,78,79,80,81,82,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,126,127,132,133,134,135,143],"query-features":[83,87],"sql-commands":[37,38],"time-geo-types":[104,105,106,107,108,109,110,111,112,113,114,115,116,136,137,138,139,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163]}, "change-column": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,23,24,25,26,27]}, - "charvarchar": {"depends-on-command":[50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80],"fn-number-format":[87,88,89],"fn-string":[85,86],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,81,82,83,84]}, + "charvarchar": {"depends-on-command":[50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80],"fn-string":[85,86],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,81,82,83,84]}, "collations-aliases": {"depends-on-command":[16,17,18,19,20,21,22,23,24,25,26,28,29],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,27,30,31]}, "collations-basic": {"depends-on-command":[8,9,10,11,12,13,14,18,34,35,59,60,61,62,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132],"parser-pipe-collate":[21,22,23,24,25,26,27,28,29,30,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56],"sql-commands":[0,1,2,3,4,5,6,7,15,16,17,19,20,31,32,33,36,57,58,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,133,134,135,136]}, "collations-padding-trim": {"depends-on-command":[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,68]}, @@ -482,7 +451,7 @@ "columnresolution": {"depends-on-command":[7,8,9,10,11,12,14,15,16,17,18,20,21,22,24,25,26,27,31,32,34,35,37,42,43,44,45,46,47,48,49,50,51],"sql-commands":[0,1,2,3,4,5,6,13,19,23,28,29,30,36,39,40,41,52,53,54]}, "columnresolution-negative": {"depends-on-command":[8,9,10,11,12,14,15,16,17,18,21,22,23,25,30,35],"sql-commands":[0,1,2,3,4,5,7,13,20,24,26,27,28,29,31,32,33,34,36,37]}, "columnresolution-views": {"depends-on-command":[9,10,11,12,13,14,15],"sql-commands":[8,16]}, - "conditional-functions": {"conditional-physical":[5,6,8,9,13,14,15,16],"depends-on-command":[1,2,3,4,7,10],"sql-commands":[0,17]}, + "conditional-functions": {"depends-on-command":[1,2,3,4,7,10],"sql-commands":[0,17]}, "count": {"depends-on-command":[1,2,3,4,8,9,10,11,12,18],"legacy-configs":[14,16,20],"sql-commands":[0]}, "cross-join": {"depends-on-command":[2,3,4,5,6,11,12],"sql-commands":[0,1,7,8,9,10]}, "csv-functions": {"depends-on-command":[13],"fn-url-xml-csv":[0,1,2,3,4,5,6,7,8,9,10,11,15,16,17,18,19,20,21,22,33,34,35,36,37,38],"sql-commands":[12],"time-geo-types":[23,24,25,26,27,28,29,30,31,32]}, @@ -494,16 +463,16 @@ "cte-recursion": {"depends-on-command":[6,12,45,48,49,52,53,61,67],"query-features":[0,1,2,3,4,8,10,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,31,32,33,34,35,36,37,38,39,40,41,42,43,55,56,57,58,59,63,64,69,70,71,72,73,74,75,77,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100],"sql-commands":[5,7,11,13,44,46,47,50,51,54,60,62,65,66,68]}, "cte-with-multi-children-operators": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15],"sql-commands":[0,1]}, "current_database_catalog": {"fn-misc":[0]}, - "date": {"cast-matrix":[8,9],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99],"depends-on-command":[68,69],"fn-json":[76],"fn-url-xml-csv":[77],"nested-interval-types":[74]}, + "date": {"cast-matrix":[8,9],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,53,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99],"depends-on-command":[68,69],"fn-json":[76],"fn-url-xml-csv":[77],"nested-interval-types":[74]}, "datetime-formatting": {"datetime":[31,32,33],"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0]}, "datetime-formatting-invalid": {"datetime":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36]}, "datetime-formatting-legacy": {"datetime":[31,32,33],"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0]}, - "datetime-legacy": {"cast-matrix":[8,9,106,107,108],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99,102,109,110,111,112,113,114,115,116,117,118,119,120,121,122,125,126,127,128,129,130,131,134,136,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,161,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,213,214,215,216,217,219,220,221,222,225,226,227,228,231,232,233,234,237,238,239,240],"depends-on-command":[68,69,163,165,166,211,212],"fn-json":[76,223],"fn-url-xml-csv":[77,224],"nested-interval-types":[74,218],"sql-commands":[162,164],"time-geo-types":[123,124,132,133,135,137]}, + "datetime-legacy": {"cast-matrix":[8,9,106,107,108],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,53,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99,102,109,110,111,112,113,114,115,116,117,118,119,120,121,122,125,126,127,128,129,130,131,134,136,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,161,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,213,214,215,216,217,219,220,221,222,225,226,227,228,231,232,233,234,237,238,239,240],"depends-on-command":[68,69,163,165,166,211,212],"fn-json":[76,223],"fn-url-xml-csv":[77,224],"nested-interval-types":[74,218],"sql-commands":[162,164],"time-geo-types":[123,124,132,133,135,137]}, "datetime-parsing": {"datetime":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]}, "datetime-parsing-invalid": {"cast-matrix":[27],"datetime":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,23,24,25,26],"fn-url-xml-csv":[18]}, "datetime-parsing-legacy": {"datetime":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]}, - "datetime-special": {"datetime":[1,2,3],"output-names":[0]}, - "decimalArithmeticOperations": {"depends-on-command":[6,7,30,31],"output-names":[13,21,37],"sql-commands":[4,5,54]}, + "datetime-special": {"datetime":[1,2,3]}, + "decimalArithmeticOperations": {"depends-on-command":[6,7,30,31],"sql-commands":[4,5,54]}, "describe": {"depends-on-command":[42,43,44,45,46,47],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67]}, "describe-part-after-analyze": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]}, "describe-query": {"depends-on-command":[15],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,16,17,18]}, @@ -531,7 +500,7 @@ "group-by-ordinal": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,17,18,19,20,21,22,23,24,25,26,27,28,29,30,32,34],"query-features":[31],"sql-commands":[0]}, "grouping_set": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,16,17,19,20,21,23,25,26,27,30,31,32,33,34,35,37,38,39,41,42,43,44,45],"query-features":[18,22,24,28,29],"sql-commands":[0,36,40]}, "grouping_set_grand_total_disabled": {"query-features":[0,1,2,3,4,5,6,7]}, - "having": {"conditional-physical":[48],"depends-on-command":[1,2,3,4,14,15,16,17,18,19,20,21,22,23,28,29,30,31,32],"query-features":[5,6,7,8,9,10,11,12,13,24,25,26,27,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,49],"sql-commands":[0]}, + "having": {"depends-on-command":[1,2,3,4,14,15,16,17,18,19,20,21,22,23,28,29,30,31,32],"query-features":[5,6,7,8,9,10,11,12,13,24,25,26,27,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,49],"sql-commands":[0]}, "having-and-order-by-recursive-type-name-resolution": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44]}, "higher-order-functions": {"depends-on-command":[3,4,5,6,7,9,11,12,13,14,16,17,18,20,22,26,27,28,29,30,31],"hof":[1,2,23,24,34,35,36,38,39,40,42,43,44,46,47,48,50,51,52,54,55,56,58,59,60,62,63,64,66,67,68,70,71,72,74,75,76,78,79,80,82],"nested-interval-types":[8,10,15,19,21,37,41,45,49,53,57,61,65,69,73,77,81],"query-features":[32,33],"sql-commands":[0,25]}, "hll": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17],"fn-aggregate":[31,32,33],"query-features":[18,19,20,21,22,23,24,25,26,27,28,29,30],"sql-commands":[0,1,2,3,4,5,6,7,34,35,36]}, @@ -558,13 +527,12 @@ "linear-regression": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"sql-commands":[0]}, "listagg": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,21,41,42,43,44,45,46,47],"query-features":[18,19,20,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,48,49,50],"sql-commands":[0,1]}, "listagg-collations": {"parser-pipe-collate":[0,1,3,4,5,6,7,8,10,12,14],"query-features":[2,9,11,13]}, - "literals": {"datetime":[36,45,52],"fn-array":[48],"fn-map":[47],"fn-struct":[49],"legacy-configs":[59,60],"nested-interval-types":[46],"output-names":[20,21,26,39,43]}, + "literals": {"datetime":[36,45,52],"fn-array":[48],"fn-map":[47],"fn-struct":[49],"legacy-configs":[59,60],"nested-interval-types":[46]}, "map": {"fn-array":[0],"fn-map":[2,3,4,5,6,7,8,9],"nested-interval-types":[1]}, "mask-functions": {"fn-string":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,29,30,31,32,33,34,35,36,37,38,39,40,41,42,55,56],"query-features":[15,16,17,18,19,20,21,22,23,24,25,26,27,28,43,44,45,46,47,48,49,50,51,52,53,54]}, - "math": {"fn-string":[56,57,58,59,60,61,62,63,64,65]}, "max-min-by-k": {"depends-on-command":[1,2,3,4,5,6,8,9,11,12,14,15,17,18,20,21,22,23,24,25],"sql-commands":[0,7,10,13,16,19,26,27,28,29,30,31]}, "metadata_column_resolution": {"depends-on-command":[5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53],"sql-commands":[0,1,2,3,4,54,55,56,57]}, - "misc-functions": {"datetime":[4],"depends-on-command":[15],"fn-misc":[0,1,2,3,5,6,7,8,9,10,11,12,14,16,17,18,19,20],"query-features":[25],"sql-commands":[13]}, + "misc-functions": {"datetime":[4],"depends-on-command":[15],"fn-misc":[0,1,2,3,5,6,7,9,11,16],"query-features":[25],"sql-commands":[13]}, "mode": {"depends-on-command":[1,2,3,14,15,16,17,18,19,20,21,22,23,24,26,27],"query-features":[4,5,6,7,8,9,10,11,12,13],"sql-commands":[0,25]}, "name-precedence-in-order-by-and-having-with-conflicting-attributes": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"query-features":[18,19,39,40],"sql-commands":[0,1,44,45]}, "named-function-arguments": {"depends-on-command":[5,6,7,26],"fn-string":[33],"query-features":[0,1,2,3,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,27,28,29,30,31,32],"sql-commands":[4,25]}, @@ -572,20 +540,19 @@ "non-excludable-rule": {"query-features":[1,3,5]}, "nonansi/array": {"depends-on-command":[1,2,3,5,6,7,8,11],"fn-array":[9,10,12,13,14,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,53,54,55,56,57,59,60,63,64,65,66,67,68,69,70,71,74,76,77,78,79,80,83,85,86,87],"fn-string":[15,16,17,18,19,20,21],"nested-interval-types":[22,23,52,72,73,75,81,82,84],"query-features":[62],"sql-commands":[0,4]}, "nonansi/cast": {"cast-matrix":[58,59,60,66,67,70,71,130,131],"fn-string":[28,29,30,31,32,33,34,35,36,124,125],"nested-interval-types":[39,40,41,43,44,72,73,74,75,76,77,78,79,80,81,82,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,126,127,132,133,134,135,143],"query-features":[83,87],"sql-commands":[37,38],"time-geo-types":[104,105,106,107,108,109,110,111,112,113,114,115,116,136,137,138,139,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163]}, - "nonansi/conditional-functions": {"conditional-physical":[5,6,8,9,13,14,15,16],"depends-on-command":[1,2,3,4,7,10],"sql-commands":[0,17]}, - "nonansi/date": {"cast-matrix":[8,9],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,41,53,54,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99],"depends-on-command":[68,69],"fn-json":[76],"fn-url-xml-csv":[77],"nested-interval-types":[74]}, + "nonansi/conditional-functions": {"depends-on-command":[1,2,3,4,7,10],"sql-commands":[0,17]}, + "nonansi/date": {"cast-matrix":[8,9],"datetime":[3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,40,53,59,60,61,62,63,64,65,66,67,70,71,72,73,75,78,79,80,81,82,83,84,85,86,87,90,91,92,93,94,95,96,97,98,99],"depends-on-command":[68,69],"fn-json":[76],"fn-url-xml-csv":[77],"nested-interval-types":[74]}, "nonansi/datetime-parsing-invalid": {"cast-matrix":[27],"datetime":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,19,20,21,22,23,24,25,26],"fn-url-xml-csv":[18]}, - "nonansi/datetime-special": {"datetime":[1,2,3],"output-names":[0]}, - "nonansi/decimalArithmeticOperations": {"depends-on-command":[6,7,30,31],"output-names":[13,21,37,45],"sql-commands":[4,5,54]}, + "nonansi/datetime-special": {"datetime":[1,2,3]}, + "nonansi/decimalArithmeticOperations": {"depends-on-command":[6,7,30,31],"sql-commands":[4,5,54]}, "nonansi/double-quoted-identifiers": {"nested-interval-types":[20,24],"query-features":[16],"sql-commands":[10,11,12]}, "nonansi/higher-order-functions": {"depends-on-command":[3,4,5,6,7,9,11,12,13,14,16,17,18,20,22,26,27,28,29,30,31],"hof":[1,2,23,24,34,35,36,38,39,40,42,43,44,46,47,48,50,51,52,54,55,56,58,59,60,62,63,64,66,67,68,70,71,72,74,75,76,78,79,80,82],"nested-interval-types":[8,10,15,19,21,37,41,45,49,53,57,61,65,69,73,77,81],"query-features":[32,33],"sql-commands":[0,25]}, "nonansi/interval": {"datetime":[0,4,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86],"depends-on-command":[160,161,162,163],"nested-interval-types":[2,3,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,39,40,42,43,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,87,88,89,90,91,92,93,94,96,97,98,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,121,122,123,124,125,126,127,128,129,130,131,148,150,151,152,153,154,155,156,157,158,164,165,166,167,168,169,170,171,172,173,174,175,176,177,179,189,190,191,192,202,203,204,205,206,209,210,211,212,215,216,217,218,219,220,221,222,223,224,225,226,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285],"query-features":[184,185,186]}, "nonansi/keywords": {"query-features":[0,1]}, - "nonansi/literals": {"datetime":[36,45,52],"fn-array":[48],"fn-map":[47],"fn-struct":[49],"legacy-configs":[59,60],"nested-interval-types":[46],"output-names":[20,21,26,39,43]}, + "nonansi/literals": {"datetime":[36,45,52],"fn-array":[48],"fn-map":[47],"fn-struct":[49],"legacy-configs":[59,60],"nested-interval-types":[46]}, "nonansi/map": {"fn-array":[0],"fn-map":[2,3,4,5,6,7,8,9],"nested-interval-types":[1]}, - "nonansi/math": {"fn-string":[56,57,58,59,60,61,62,63,64,65]}, "nonansi/parse-schema-string": {"fn-json":[2,3],"fn-url-xml-csv":[0,1]}, - "nonansi/string-functions": {"depends-on-command":[218],"fn-misc":[5],"fn-number-format":[173,174,175,176,177,178,179,180,181],"fn-regex":[13,14,15,16,17,18,19,20,21,22,23,24,25,26],"fn-string":[0,1,6,7,8,9,10,11,12,27,28,29,30,31,32,33,34,35,36,60,61,62,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,98,101,103,106,109,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,130,133,136,139,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252],"output-names":[4,38,39,41,42,43,44,45,47,48,51,52,53,54,55,56,57,58,63,64],"query-features":[37,99,102,104,107,110,128,131,134,137,140],"sql-commands":[217]}, + "nonansi/string-functions": {"depends-on-command":[218],"fn-misc":[5],"fn-regex":[13,14,15,16,17,18,19,20,21,22,23,24,25,26],"fn-string":[0,1,6,7,8,9,10,11,12,27,28,29,30,31,32,33,34,35,36,60,61,62,98,101,103,106,109,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,130,133,136,139,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252],"query-features":[37,99,102,104,107,110,128,131,134,137,140],"sql-commands":[217]}, "nonansi/timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62],"time-geo-types":[21,22,30,31,33,35]}, "nonansi/try_aggregates": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31]}, "nonansi/try_arithmetic": {"cast-matrix":[2,32,43,58],"coercion":[3,33,44,59],"datetime":[11,12,17,18],"nested-interval-types":[13,14,15,16,19,20,21,22,23,24,25,35,36,37,38,39,40,52,53,54,55,67,68,69,70,71,72],"query-features":[10,34,51,66]}, @@ -593,7 +560,7 @@ "nonansi/try_element_at": {"fn-array":[0,1,2,3,4,5,6,7]}, "null-handling": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29],"sql-commands":[0,1,2,3,4,5,6,7,30]}, "null-propagation": {"query-features":[0,1,2,3]}, - "operators": {"fn-string":[57,60,65,66,67,68,69,70,71,72,73,74,75,76],"output-names":[32,33,34,35,36,37,38,39,40,41,42,43,46,48,50,51,52,53,54,55,62]}, + "operators": {"fn-string":[57,60,65,66,67,68,69,70,71,72,73,74,75,76],"output-names":[55]}, "order-by": {"depends-on-command":[1,2,3,4,7,8,9,10,11,15,16,17,18,19,20,21,22,23,24,25,26,27],"query-features":[5,6,12,13,28,29,30,31,32,33,34,35],"sql-commands":[0],"variant-type":[14]}, "order-by-alias": {"depends-on-command":[1,2,3,4,5,6,7,9,10,11,12],"query-features":[14,15,16,17],"sql-commands":[0]}, "order-by-all": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14],"query-features":[15,16,17],"sql-commands":[0]}, @@ -607,7 +574,7 @@ "parse-query-correctness-old-behavior": {"depends-on-command":[1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,38,40,42,46,48,50,52,54,56,58,60,62,64],"sql-commands":[37,39,41,43,44,45,47,49,51,53,55,65]}, "parse-schema-string": {"fn-json":[2,3],"fn-url-xml-csv":[0,1]}, "percentiles": {"depends-on-command":[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,36,37,38,39,40,41,42,43,44],"query-features":[45,46,47,48,50,51],"sql-commands":[0,1,35]}, - "pipe-operators": {"depends-on-command":[25,26,27,28,29,30,31,32,33,34,37,38,39,41,42,43,44,45,47,48,49,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,88,89,92,93,94,95,96,99,100,101,103,105,106,107,110,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,184,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,205,206,207,208,209,210,211,212,214,215,216,217,218,219,220,233,234,235,238,241,242,244,245,246,247,248,250,251,252,254,256,257,258,259,260,261,262,263,264,265,266,267,268,269,277,281,282,283,284,285,287,288,290,292,296,300,301,302,303,304,305,307,308,310,311,312,313],"parser-pipe-collate":[35,40,46,50,90,91,97,98,102,104,166,204,221,222,223,224,225,226,227,228,229,230,231,232,236,237,239,240,243,255,270,271,272,273,274,275,276,278,279,280,286,298,306,309],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,289,294,314,315,316]}, + "pipe-operators": {"depends-on-command":[25,26,27,28,29,30,31,32,33,34,37,38,39,41,42,43,44,45,47,48,49,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,88,89,92,93,94,95,96,99,100,101,103,105,106,107,110,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,184,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,205,206,207,208,209,210,211,212,214,215,216,217,218,219,220,233,234,235,238,241,242,244,245,246,247,248,250,251,252,254,256,257,258,259,260,261,262,263,264,265,266,267,268,269,277,281,282,283,284,285,287,288,290,292,296,300,301,302,303,304,305,307,308,310,311,312,313],"parser-pipe-collate":[35,40,46,50,90,91,97,98,102,104,166,204,221,222,223,224,225,226,227,228,229,230,231,232,236,237,239,240,243,255,270,271,272,273,274,275,276,278,279,280,286,306,309],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,289,294,314,315,316]}, "pivot": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"sql-commands":[0,1,2]}, "postgreSQL/aggregates_part1": {"depends-on-command":[45,46,47,48],"fn-aggregate":[9,10,11,12,13,14,15,16,17,18,35,36,37,38,39,40,41,42,43],"query-features":[19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"sql-commands":[44,49],"subqueries":[54,55]}, "postgreSQL/aggregates_part2": {"depends-on-command":[2,3,4,5,6,7,8,12,13,14,15],"generators":[27],"sql-commands":[0,1,11]}, @@ -616,37 +583,37 @@ "postgreSQL/boolean": {"cast-matrix":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39],"depends-on-command":[44,45,46,47,49,56,57,58,59,60,61,62,63,64,65,66,67,68,73,76,77,78,79,80,81,82,83,84,85,86,87],"sql-commands":[40,41,42,43,48,50,51,52,53,54,55,69,70,71,72,74,75,88,89,90,91]}, "postgreSQL/case": {"depends-on-command":[20,22,23,24,25,26,27,28,29,30,31],"fn-string":[17],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,33,34],"test-udfs":[32]}, "postgreSQL/create_view": {"depends-on-command":[11,13,83,84],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,12,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194]}, - "postgreSQL/date": {"datetime":[48,49,50,51,52,53,54,55,56,57,58],"depends-on-command":[16,17,18,46,47],"output-names":[44,45],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,59]}, + "postgreSQL/date": {"datetime":[48,49,50,51,52,53,54,55,56,57,58],"depends-on-command":[16,17,18,46,47],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,59]}, "postgreSQL/float4": {"cast-matrix":[6,7,8,9,10,11,12,13,14,15,16,17,30,31,32,33,34,35,36,37,38,39,40,41],"depends-on-command":[18,19,20,21,22,23,24,25,26,27,28,29],"sql-commands":[0,1,2,3,4,5,42]}, "postgreSQL/float8": {"cast-matrix":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,38,39,40,41,42,43,44,45,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,82,83,84,85,86,87,88,89,90,91,92,93],"depends-on-command":[22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,46,47,49,50,81],"sql-commands":[0,1,2,3,4,5,48,75,76,77,78,79,80,94]}, - "postgreSQL/groupingsets": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17,18,19,20,25,28,29,35,36,37,38,39,40,41,42,43,44,45,46,47],"grouping-sets":[21,22,23,27,30,31,32,33,34],"query-features":[48,49],"sql-commands":[0,1,2,3,4,5,6,7,24,26,50,51,52,53,54]}, + "postgreSQL/groupingsets": {"depends-on-command":[8,9,10,11,12,13,14,15,16,17,18,19,20,25,28,29,35,36,37,38,39,40,41,42,43,44,45,46,47],"grouping-sets":[27,34],"query-features":[48,49],"sql-commands":[0,1,2,3,4,5,6,7,24,26,50,51,52,53,54]}, "postgreSQL/insert": {"depends-on-command":[5,7],"sql-commands":[0,1,2,3,4,6,8]}, "postgreSQL/int2": {"cast-matrix":[29,30,31],"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28],"query-features":[32,33],"sql-commands":[0,1,2,3,4,5,34]}, "postgreSQL/int4": {"cast-matrix":[39,40,41,42,46,47,48,49],"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"query-features":[50,51],"sql-commands":[0,1,2,3,4,5,52]}, "postgreSQL/int8": {"cast-matrix":[62,63,64,69,71,72,77,78,79,80,81,82,83,84,85,86,87],"depends-on-command":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,65,66,67,68,70,73],"query-features":[74,75,76,88,89],"sql-commands":[0,1,2,3,4,5,90]}, "postgreSQL/interval": {"nested-interval-types":[0,1,2,3,4,5,6,7,8,9,10,11,14,17]}, - "postgreSQL/join": {"conditional-physical":[134,135],"depends-on-command":[28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,65,66,67,68,69,70,71,72,73,74,75,76,79,80,81,82,83,84,85,86,87,88,89,91,92,93,94,95,96,105,106,110,113,116,120,122,126,127,128,129,133,136,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,160,161,162,163,166,167,169,170,171,172,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,196],"sql-commands":[0,1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,55,56,57,58,59,60,61,62,63,64,77,78,98,99,100,101,102,103,104,108,109,111,112,114,115,117,118,119,121,124,125,130,131,132,137,138,139,158,159,164,165,168,191,192,193,194,195,197,198]}, + "postgreSQL/join": {"depends-on-command":[28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,65,66,67,68,69,70,71,72,73,74,75,76,79,80,81,82,83,84,85,86,87,88,89,91,92,93,95,96,105,106,110,113,116,120,122,126,127,128,129,133,136,140,141,142,143,144,145,146,147,149,150,151,152,153,154,155,156,157,160,161,162,163,166,167,169,170,171,172,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,196],"sql-commands":[0,1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,55,56,57,58,59,60,61,62,63,64,77,78,98,99,100,101,102,103,104,108,109,111,112,114,115,117,118,119,121,124,125,130,131,132,137,138,139,158,159,164,165,168,191,192,193,194,195,197,198]}, "postgreSQL/limit": {"depends-on-command":[9,10],"fn-string":[12],"sql-commands":[8,11]}, - "postgreSQL/numeric": {"cast-matrix":[507,508,509,510,511,512],"depends-on-command":[460,463,466,469,472,475,478,481,484,487,490,493,496,497,505,521,533,538,539,540,541,542,558],"fn-number-format":[543,544,545,546,547,548,549,550,551],"fn-string":[523,524,525,526,527,528,529,530,534,535,536],"output-names":[561,563,564,565,569,570,571,572,573,574,575,579,585,586,587,588,589,590,591,592],"query-features":[576,577,578,593,594],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,461,462,464,465,467,468,470,471,473,474,476,477,479,480,482,483,485,486,488,489,491,492,494,495,498,499,500,501,502,503,504,506,513,514,515,516,517,518,519,520,522,531,532,537,552,553,554,555,556,557,595,596,597,598,599,600,601,602,603,604,605]}, + "postgreSQL/numeric": {"cast-matrix":[507,508,509,510,511,512],"depends-on-command":[460,463,466,469,472,475,478,481,484,487,490,493,496,497,505,521,533,538,539,540,541,542,558],"fn-string":[523,524,525,526,527,528,529,530,534,535,536],"query-features":[576,577,578,593,594],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,461,462,464,465,467,468,470,471,473,474,476,477,479,480,482,483,485,486,488,489,491,492,494,495,498,499,500,501,502,503,504,506,513,514,515,516,517,518,519,520,522,531,532,537,552,553,554,555,556,557,595,596,597,598,599,600,601,602,603,604,605]}, "postgreSQL/select": {"depends-on-command":[18,20,21,22,23,24],"query-features":[16,17,34,35],"sql-commands":[1,12,19,36]}, "postgreSQL/select_distinct": {"depends-on-command":[7,8,9,10],"sql-commands":[6]}, "postgreSQL/select_having": {"depends-on-command":[11,12,13,14,15,16,17,18,19,20],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,21]}, "postgreSQL/select_implicit": {"depends-on-command":[11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36],"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,37]}, - "postgreSQL/strings": {"cast-matrix":[2,3,4,5,6,7,70,86,87,88,89,90,91,92,93,94,95,96,97,98,99,119,120,121,122],"depends-on-command":[76,77],"fn-string":[14,15,16,17,18,19,79,80,84,85,100,111,112,113,114,115,116,117,118],"output-names":[102,104,107,109],"sql-commands":[71,72,73,74,75,123]}, + "postgreSQL/strings": {"cast-matrix":[2,3,4,5,6,7,70,86,87,88,89,90,91,92,93,94,95,96,97,98,99,119,120,121,122],"depends-on-command":[76,77],"fn-string":[14,15,16,17,18,19,79,80,85,100,111,112,113,114,115,116,117,118],"sql-commands":[71,72,73,74,75,123]}, "postgreSQL/text": {"cast-matrix":[0,1,7],"datetime":[11],"depends-on-command":[5],"fn-array":[17],"fn-string":[12,13,14,15,16,20,21,22,23,26,27,28,31,32,33,34,35,36,37,38,39,40],"query-features":[18],"sql-commands":[2,3,4,19,41]}, "postgreSQL/timestamp": {"datetime":[25,28],"depends-on-command":[8,9,10,17,18,19,20,21,22,23,24,26,27],"sql-commands":[0,1,2,3,4,5,6,7,11,12,13,14,15,16,29]}, "postgreSQL/union": {"cast-matrix":[13,15,17,68],"depends-on-command":[20,21,22,23,24,25,26,27,28,29,30,31,32,41,42,43,44,45,46,47,48,49,50,51,52,69,70,71],"query-features":[53,54,55,56,57,58,59,60,61,62,63,64,67],"sql-commands":[0,1,2]}, - "postgreSQL/window_part1": {"depends-on-command":[27,39],"sql-commands":[26,38,40,42],"window":[12,13,14,15,32,33,34,35,36,37]}, + "postgreSQL/window_part1": {"depends-on-command":[27,39],"sql-commands":[26,38,40,42]}, "postgreSQL/window_part2": {"depends-on-command":[17,18,19,20,21,22,23,24,25,26,27,28],"query-features":[9,10,11,12,13,14],"sql-commands":[0,1,15,16,29,30],"window":[2,3,4,5,6,7,8]}, - "postgreSQL/window_part3": {"depends-on-command":[12,13,14,15,17,18,19,21,22,24],"sql-commands":[1,2,3,4,10,11,27,28,29],"window":[5,6,7,8,26]}, + "postgreSQL/window_part3": {"depends-on-command":[12,13,14,15,17,18,19,21,22,24],"sql-commands":[1,2,3,4,10,11,27,28,29],"window":[5,6,7,8]}, "postgreSQL/window_part4": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38]}, - "postgreSQL/with": {"depends-on-command":[5,7,12,23,24,25,26,32,34,38,39,40,43,44,45,46,47,59,60,61,68,69,70,71,72,73,81,86,87,88,89,92,93,97,99,100],"fn-string":[1],"query-features":[2,3,8,9,10,13,28,35,51,52,53,54,55,56,62,63,64,65,66,67,75,78,79],"sql-commands":[4,6,14,15,16,17,18,19,20,21,22,31,33,36,37,41,42,48,49,50,57,58,80,82,83,84,85,90,91,94,95,98,101,102,103,104,105,106,107,108,109,110]}, + "postgreSQL/with": {"depends-on-command":[5,7,12,23,24,25,26,32,34,38,39,40,43,44,45,46,47,59,60,61,68,69,70,71,72,73,81,86,87,88,89,92,93,97,99,100],"fn-string":[1],"query-features":[2,3,8,9,10,13,28,35,51,52,53,54,55,56,62,63,64,65,66,67,75,78,79],"sql-commands":[4,6,14,15,16,17,18,19,20,21,22,31,33,36,37,41,42,48,49,50,57,58,80,82,83,84,85,90,91,98,101,102,103,104,105,106,107,108,109,110]}, "pred-pushdown": {"depends-on-command":[2,3],"sql-commands":[0,1]}, "predicate-functions": {"datetime":[30,31,37,38,44,45,51,52,53,54,55,56,57,80,86],"fn-string":[81,87]}, "qualify": {"depends-on-command":[1,2,4,5,6,7,8],"sql-commands":[0,3]}, "query_regex_column": {"depends-on-command":[3,4,5,6,7,8,10,11,12,13,14,15,16,17,18,19,20,21,24,25,26,27,28,29,30,31,32,33],"sql-commands":[1,2,23]}, "random": {"fn-string":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,61,62,63,64,65,66,67,70,71],"query-features":[25,41,42,60,68,69,72,73]}, - "regexp-functions": {"fn-regex":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,32,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67],"query-features":[31,68]}, + "regexp-functions": {"fn-regex":[7,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,32,42,43,44,45,46,47,62,63,64,65,66,67],"query-features":[31,68]}, "replacing-missing-expression-with-alias": {"query-features":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]}, "runtime-replaceable-edge-cases": {"fn-url-xml-csv":[0]}, "scripting/randomly_generated_scripts": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124]}, @@ -657,7 +624,7 @@ "show-tblproperties": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,11]}, "show-views": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]}, "show_columns": {"sql-commands":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]}, - "sql-compatibility-functions": {"cast-matrix":[8,9,10,11],"conditional-physical":[0,1,2,3,4,5,6,7],"depends-on-command":[13],"query-features":[14],"sql-commands":[12]}, + "sql-compatibility-functions": {"cast-matrix":[8,9,10,11],"depends-on-command":[13],"query-features":[14],"sql-commands":[12]}, "sql-on-files": {"depends-on-command":[4,9,14,19],"files":[2,7,12,17],"object-stores":[22],"sql-commands":[0,1,5,6,10,11,15,16,20,21]}, "sql-path": {"depends-on-command":[38,42,47,49,64,66,81,82,87,103,104,108,113],"fn-misc":[0,2,4,6,9,11,14,18,21,23,26,27,125,131,137],"sql-commands":[1,3,5,7,8,10,12,13,15,16,17,19,20,22,24,25,28,29,30,31,32,33,34,35,36,37,39,40,41,43,44,45,46,48,50,51,53,54,55,56,57,58,59,60,61,62,63,65,67,69,70,71,72,73,74,75,76,77,78,79,80,83,84,85,86,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,105,106,107,109,110,111,112,114,115,116,117,118,119,120,121,122,124,126,129,130,133,134,135,138]}, "sql-session-variables": {"depends-on-command":[4,6,10,12,15,21,32,34,36,38,40,42,44,46,60,63,79,81,83,85,87,89,91,93,104,106,108,110,112,114,120,127,129,134,144,148,166,168,170,172,174,189,194,197,200,203,206,209,212,234,235,236,237,241,242,243,244,245,246,247,248,250,251,252,254,264],"sql-commands":[1,2,3,5,7,8,9,11,13,14,16,18,19,20,22,24,25,26,29,30,31,33,35,37,39,41,43,45,47,48,49,50,51,52,53,54,55,56,57,58,59,61,62,64,66,67,68,69,70,75,76,77,78,80,82,84,86,88,90,92,94,95,96,97,98,99,100,101,102,103,105,107,109,111,113,115,116,117,118,119,121,122,123,124,125,126,128,130,131,132,133,135,136,137,138,139,140,141,142,143,145,146,147,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,167,169,171,173,176,177,178,179,180,181,182,183,184,185,186,187,188,190,191,192,193,195,196,198,199,201,202,204,205,207,208,210,211,213,214,215,216,217,218,219,220,221,226,227,228,229,230,231,232,233,238,239,240,253,255,256,257,258,259,261,262,263,265]}, @@ -665,7 +632,7 @@ "sql-udf-name-precedence": {"depends-on-command":[2,4,6,8,10,14,16,18,20,23,25],"sql-commands":[1,3,5,7,9,11,13,15,17,19,21,22,24,26,28,29,30,31,32,33,34,35,36,37,38,39]}, "sql-udf-name-precedence-legacy": {"depends-on-command":[2,4,6,8,10,12,14,16,18,20,23,25],"sql-commands":[1,3,5,7,9,11,13,15,17,19,21,22,24,26,28,29,30,31,32,33,34,35,36,37,38,39]}, "st-functions": {"depends-on-command":[16,17,18,19,20,21,22,23,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,58,59,69,70,71,72,73,84,85,86,87,88,89,90,91,92,96,97,102,103,104,105],"sql-commands":[0,1,2,106],"time-geo-types":[3,4,5,6,7,8,9,10,11,12,13,14,15,24,25,26,27,28,29,30,31,32,33,34,53,54,55,56,57,60,61,62,63,64,65,66,67,68,74,75,76,77,78,79,80,81,82,83,93,94,95,98,99,100,101]}, - "string-functions": {"depends-on-command":[218],"fn-misc":[5],"fn-number-format":[173,174,175,176,177,178,179,180,181],"fn-regex":[13,14,15,16,17,18,19,20,21,22,23,24,25,26],"fn-string":[0,1,6,7,8,9,10,11,12,27,28,29,30,31,32,33,34,35,36,60,61,62,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,98,101,103,106,109,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,130,133,136,139,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252],"output-names":[4,38,39,41,42,43,44,45,47,48,51,52,53,54,55,56,57,58],"query-features":[37,99,102,104,107,110,128,131,134,137,140],"sql-commands":[217]}, + "string-functions": {"depends-on-command":[218],"fn-misc":[5],"fn-regex":[13,14,15,16,17,18,19,20,21,22,23,24,25,26],"fn-string":[0,1,6,7,8,9,10,11,12,27,28,29,30,31,32,33,34,35,36,60,61,62,98,101,103,106,109,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,130,133,136,139,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252],"query-features":[37,99,102,104,107,110,128,131,134,137,140],"sql-commands":[217]}, "struct": {"depends-on-command":[3,4,5,6,7,8],"nested-interval-types":[1,2,9,11,13],"query-features":[10,12],"sql-commands":[0]}, "subexp-elimination": {"depends-on-command":[1,2,3,4,5,6,7,8],"sql-commands":[0]}, "subquery/exists-subquery/exists-aggregate": {"depends-on-command":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],"sql-commands":[0,1,2]}, @@ -718,11 +685,11 @@ "time-bucket": {"datetime":[13,27],"nested-interval-types":[1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,17,20,21,24,25,26,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64],"query-features":[18,19,22,23,65,66,67,69,70,71,72,73]}, "timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62],"time-geo-types":[21,22,30,31,33,35]}, "timestamp-ltz": {"datetime":[0,1,2,3,4,5,6,7,9,10,11,12,13,14,15,17,18,19,20,21],"time-geo-types":[8,16]}, - "timestamp-ntz": {"datetime":[0,1,2,3,4,5,6,7,9,10,11,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28],"depends-on-command":[32],"sql-commands":[29,30,31,33],"time-geo-types":[8,13,15]}, - "timestampNTZ/datetime-special": {"datetime":[1,2,3],"output-names":[0]}, - "timestampNTZ/datetime-special-ansi": {"datetime":[1,2,3],"output-names":[0]}, - "timestampNTZ/timestamp": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62],"time-geo-types":[21,22,30,31,33,35]}, - "timestampNTZ/timestamp-ansi": {"cast-matrix":[4,5,6],"datetime":[0,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62],"time-geo-types":[21,22,30,31,33,35]}, + "timestamp-ntz": {"datetime":[1,2,3,4,5,6,7,9,10,11,12,14,16,17,18,19,20,21,22,26,27,28],"depends-on-command":[32],"sql-commands":[29,30,31,33],"time-geo-types":[8,13,15]}, + "timestampNTZ/datetime-special": {"datetime":[1,3]}, + "timestampNTZ/datetime-special-ansi": {"datetime":[1,3]}, + "timestampNTZ/timestamp": {"cast-matrix":[4,5,6],"datetime":[7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62],"time-geo-types":[21,22,30,31,33,35]}, + "timestampNTZ/timestamp-ansi": {"cast-matrix":[4,5,6],"datetime":[7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24,25,26,27,28,29,32,34,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,111,112,113,114,115,117,118,119,120,123,124,125,126,129,130,131,132,135,136,137,138],"depends-on-command":[61,63,64,109,110],"fn-json":[121],"fn-url-xml-csv":[122],"nested-interval-types":[116],"sql-commands":[60,62],"time-geo-types":[21,22,30,31,33,35]}, "timezone": {"depends-on-command":[13],"sql-commands":[0,3,4,5,6,7,8,9,10,11,12,14]}, "to_from_avro": {"depends-on-command":[3,4,5,6,7],"sql-commands":[0,1,2,8,9]}, "transform": {"depends-on-command":[3,4,5,6,7,8,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,39,41,43,44,45,49,50,51],"parser-tail":[9,38],"sql-commands":[0,1,2,11,12,37]}, @@ -743,13 +710,13 @@ "typeCoercion/native/dateTimeOperations": {"nested-interval-types":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39]}, "typeCoercion/native/decimalPrecision": {"depends-on-command":[33,34,35,36,37,38,39,40,81,82,83,84,85,86,87,88,121,122,123,124,125,126,127,128,169,170,171,172,173,174,175,176]}, "typeCoercion/native/elt": {"query-features":[0,1,3,5]}, - "typeCoercion/native/ifCoercion": {"depends-on-command":[1,2,3,4,5,6,7,8,13,14,15,16,17,18,19,20,25,26,27,28,29,30,31,32,37,38,39,40,41,42,43,44,49,50,51,52,53,54,55,56,61,62,63,64,65,66,67,68,73,74,75,76,77,78,79,80,85,86,87,88,89,90,91,92,93,94,95,96,104,105,116,118,128,131,132,140,143,144]}, + "typeCoercion/native/ifCoercion": {"depends-on-command":[93,94,95,104,105,116,118,128,131,132,143]}, "typeCoercion/native/implicitTypeCasts": {"depends-on-command":[21,22,31,32,33,34,35,39,40,41,43,46]}, "typeCoercion/native/inConversion": {"depends-on-command":[93,94,95,104,105,116,118,128,131,132,143,237,238,239,248,249,260,262,272,275,276,287]}, "typeCoercion/native/mapZipWith": {"depends-on-command":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18],"sql-commands":[0]}, "typeCoercion/native/mapconcat": {"depends-on-command":[1,2,3,4,5,6,7],"sql-commands":[0]}, "typeCoercion/native/promoteStrings": {"depends-on-command":[11,12,23,24,82,83,93,94,147,148,149,158,159,160,170,171,172,181,182,183,193,194,195,205,206,207,217,218,219,229,230,231,241,242,243,253,254,255,265,266,267,277,278,279,289,290,291,301,302,303,308,309,312,313,314,315]}, - "typeCoercion/native/stringCastAndExpressions": {"depends-on-command":[8,9,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,28,29,30,31],"fn-string":[27]}, + "typeCoercion/native/stringCastAndExpressions": {"depends-on-command":[8,9,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,28,29,30,31]}, "typeCoercion/native/widenSetOperationTypes": {"depends-on-command":[93,94,95,104,105,116,118,128,131,132,143]}, "typeCoercion/native/windowFrameCoercion": {"depends-on-command":[9,10,11,13,14,15,16,17,18,19,20,21,22,23,24]}, "udaf/udaf": {"depends-on-command":[2,3,5],"sql-commands":[0,1,4,6,7]},