From 26a1c9d90086a11be116cc44babd6a4bb82ead16 Mon Sep 17 00:00:00 2001 From: Kevin Longe <273747162+kvlonge@users.noreply.github.com> Date: Sat, 26 Sep 2026 19:28:18 +0100 Subject: [PATCH 1/2] fix: align DuckDB and PostgreSQL type inference with engine results Record DuckDB 1.5.2 and PostgreSQL 17 result types for a synthetic expression matrix and replay them in tests. Add per-engine rules for arithmetic (DuckDB `/` is DOUBLE, `//` parses as integer division), literals, aggregates, CASE/COALESCE/NULLIF unification, date/time arithmetic, casts and common scalar functions, returning no type where the engine result is not modelled. Parse bare USER as the niladic function in dialects that define it and register DuckDB's keyword time functions. --- .../src/duckdb.rs | 11 + crates/polyglot-sql/src/function_registry.rs | 17 +- .../src/optimizer/annotate_types.rs | 80 +- .../src/optimizer/annotate_types/engine.rs | 1194 +++++++ .../src/optimizer/set_operation_types.rs | 2 +- crates/polyglot-sql/src/parser.rs | 34 +- .../polyglot-sql/src/validation/coercion.rs | 9 + .../polyglot-sql/tests/engine_type_truth.rs | 292 ++ .../tests/fixtures/engine_types/duckdb.json | 2877 +++++++++++++++++ .../tests/fixtures/engine_types/postgres.json | 1362 ++++++++ crates/polyglot-sql/tests/query_analysis.rs | 2 +- tools/engine-type-truth/generate.py | 380 +++ 12 files changed, 6241 insertions(+), 19 deletions(-) create mode 100644 crates/polyglot-sql/src/optimizer/annotate_types/engine.rs create mode 100644 crates/polyglot-sql/tests/engine_type_truth.rs create mode 100644 crates/polyglot-sql/tests/fixtures/engine_types/duckdb.json create mode 100644 crates/polyglot-sql/tests/fixtures/engine_types/postgres.json create mode 100644 tools/engine-type-truth/generate.py diff --git a/crates/polyglot-sql-function-catalogs/src/duckdb.rs b/crates/polyglot-sql-function-catalogs/src/duckdb.rs index fc2949ee..cd86c6a8 100644 --- a/crates/polyglot-sql-function-catalogs/src/duckdb.rs +++ b/crates/polyglot-sql-function-catalogs/src/duckdb.rs @@ -1648,4 +1648,15 @@ pub(crate) fn register(catalog: &mut S) { catalog.register(d, "~~", vec![FunctionSignature::exact(2)]); catalog.register(d, "~~*", vec![FunctionSignature::exact(2)]); catalog.register(d, "~~~", vec![FunctionSignature::exact(2)]); + + // SQL keyword forms rewritten by DuckDB's parser rather than listed by + // duckdb_functions(); they are valid without brackets. + for name in [ + "current_time", + "current_timestamp", + "localtime", + "localtimestamp", + ] { + catalog.register(d, name, vec![FunctionSignature::exact(0)]); + } } diff --git a/crates/polyglot-sql/src/function_registry.rs b/crates/polyglot-sql/src/function_registry.rs index 15510937..709fea1c 100644 --- a/crates/polyglot-sql/src/function_registry.rs +++ b/crates/polyglot-sql/src/function_registry.rs @@ -40,7 +40,7 @@ pub(crate) const NO_PAREN_FUNCTION_NAME_LIST: &[&str] = &[ "UTC_TIMESTAMP", "SESSION_USER", "SYSTEM_USER", - // Note: USER by itself is NOT a no-paren function in standard SQL - only CURRENT_USER is + // Bare USER is dialect-specific; see `bare_user_is_function`. "PI", // MySQL/Databricks CURDATE "CURDATE", @@ -2224,6 +2224,21 @@ pub(crate) fn is_no_paren_function_name_upper(upper_name: &str) -> bool { NO_PAREN_FUNCTION_NAME_SET.contains(upper_name) } +/// Whether an unquoted, unqualified `USER` is the niladic session-user function. +/// Other dialects either require `USER()` or treat `user` as an ordinary name. +pub(crate) fn bare_user_is_function(dialect: Option) -> bool { + matches!( + dialect, + Some( + DialectType::PostgreSQL + | DialectType::Redshift + | DialectType::DuckDB + | DialectType::TSQL + | DialectType::Oracle + ) + ) +} + /// Returns true if the given uppercased name should use aggregate parsing behavior. pub(crate) fn is_aggregate_function_name_upper(upper_name: &str) -> bool { AGGREGATE_FUNCTION_NAME_SET.contains(upper_name) diff --git a/crates/polyglot-sql/src/optimizer/annotate_types.rs b/crates/polyglot-sql/src/optimizer/annotate_types.rs index e385f98c..c2b44e67 100644 --- a/crates/polyglot-sql/src/optimizer/annotate_types.rs +++ b/crates/polyglot-sql/src/optimizer/annotate_types.rs @@ -19,6 +19,8 @@ use crate::expressions::{ use crate::schema::{normalize_name, Schema, SchemaError, SchemaResult, TABLE_PARTS}; use crate::traversal::ExpressionWalk; +mod engine; + /// Type coercion class for determining result types in binary operations. /// Higher-priority classes win during coercion. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] @@ -403,6 +405,15 @@ impl<'a> TypeAnnotator<'a> { /// Annotate types for an expression tree pub fn annotate(&mut self, expr: &Expression) -> Option { + if let Some(engine) = engine::Engine::of(self._dialect) { + if let Some(result) = self.annotate_engine(engine, expr) { + return result; + } + } + self.annotate_default(expr) + } + + fn annotate_default(&mut self, expr: &Expression) -> Option { if self._dialect == Some(DialectType::Snowflake) { match expr { Expression::CurrentTimestamp(_) | Expression::CurrentTimestampLTZ(_) => { @@ -1345,6 +1356,17 @@ impl<'a> TypeAnnotator<'a> { self.annotate(&lv.this) } + /// Annotate a literal as bound by `dialect`. + pub(super) fn annotate_literal_for( + lit: &Literal, + dialect: Option, + ) -> Option { + match engine::Engine::of(dialect) { + Some(engine) => engine::literal_type(engine, lit), + None => Self::annotate_literal(lit), + } + } + /// Annotate a literal value pub(super) fn annotate_literal(lit: &Literal) -> Option { match lit { @@ -1446,6 +1468,11 @@ impl<'a> TypeAnnotator<'a> { { return func.args.first().and_then(|arg| self.annotate(arg)); } + if let Some(engine) = engine::Engine::of(self._dialect) { + if let Some(result) = self.annotate_engine_function(engine, func) { + return result; + } + } let func_name = func.name.to_uppercase(); if self._dialect == Some(DialectType::Snowflake) && !func.quoted { @@ -1589,7 +1616,10 @@ impl<'a> TypeAnnotator<'a> { }; } self.used_unknown_function_fallback = true; - if self._dialect == Some(DialectType::Snowflake) { + if engine::Engine::of(self._dialect).is_some() { + // An unmodelled function's result is not its first argument's type. + None + } else if self._dialect == Some(DialectType::Snowflake) { Some(DataType::Unknown) } else { func.args.first().and_then(|arg| self.annotate(arg)) @@ -2410,9 +2440,9 @@ fn projection_name(expression: &Expression) -> Option { } } -fn projection_type(expression: &Expression) -> DataType { +fn projection_type(expression: &Expression, dialect: Option) -> DataType { if let Expression::Literal(literal) = expression { - return TypeAnnotator::annotate_literal(literal).unwrap_or(DataType::Unknown); + return TypeAnnotator::annotate_literal_for(literal, dialect).unwrap_or(DataType::Unknown); } if matches!(expression, Expression::Boolean(_)) { return DataType::Boolean; @@ -2449,7 +2479,7 @@ fn query_outputs(expressions: &[Expression], dialect: Option) -> Ou if unknown_function { DataType::Unknown } else { - projection_type(expression) + projection_type(expression, dialect) }, ) }) @@ -3596,10 +3626,18 @@ mod tests { TypeAnnotator::new(None, Some(DialectType::DuckDB)).annotate(&expr), None ); + // PostgreSQL widens SUM(BIGINT) to NUMERIC. + let expr = parse_one("SUM(CAST(1 AS BIGINT))", DialectType::PostgreSQL).unwrap(); + assert_eq!( + TypeAnnotator::new(None, Some(DialectType::PostgreSQL)).annotate(&expr), + Some(DataType::Decimal { + precision: None, + scale: None + }) + ); // The dialect-specific override must not change the generic/default rule. for dialect in [ DialectType::Generic, - DialectType::PostgreSQL, DialectType::MySQL, DialectType::BigQuery, ] { @@ -3687,14 +3725,20 @@ mod tests { let mut restored: Expression = serde_json::from_value(unannotated).unwrap(); assert_eq!(restored, expression); annotate_types(&mut restored, None, Some(dialect)); - assert_eq!(restored.inferred_type(), Some(&varchar), "{dialect:?}"); + // PostgreSQL string functions return TEXT. + let (expected, tag) = if dialect == DialectType::PostgreSQL { + (DataType::Text, "text") + } else { + (varchar.clone(), "var_char") + }; + assert_eq!(restored.inferred_type(), Some(&expected), "{dialect:?}"); assert_eq!(restored.sql_for(dialect), expression.sql_for(dialect)); let annotated = serde_json::to_value(&restored).unwrap(); - assert_eq!(annotated["trim"]["inferred_type"]["data_type"], "var_char"); + assert_eq!(annotated["trim"]["inferred_type"]["data_type"], tag); let roundtripped: Expression = serde_json::from_value(annotated).unwrap(); assert_eq!(roundtripped, restored); - assert_eq!(roundtripped.inferred_type(), Some(&varchar)); + assert_eq!(roundtripped.inferred_type(), Some(&expected)); } } @@ -4062,10 +4106,15 @@ mod tests { Some(DialectType::Snowflake), Some(DialectType::DuckDB), ] { - let expected = if dialect == Some(DialectType::DuckDB) { - duckdb_type - } else { - &int + let numeric = DataType::Decimal { + precision: None, + scale: None, + }; + let expected = match dialect { + Some(DialectType::DuckDB) => duckdb_type, + // PostgreSQL 14+ EXTRACT returns NUMERIC for every field. + Some(DialectType::PostgreSQL) => &numeric, + _ => &int, }; assert_eq!( TypeAnnotator::new(None, dialect) @@ -4585,12 +4634,13 @@ mod tests { let Expression::Alias(alias) = &select.expressions[0] else { panic!("expected alias"); }; + // DuckDB binds 2.5 as DECIMAL(2,1); INTEGER widens to DECIMAL(11,1). assert_eq!( alias.this.inferred_type(), Some(&DataType::Array { - element_type: Box::new(DataType::Double { - precision: None, - scale: None, + element_type: Box::new(DataType::Decimal { + precision: Some(11), + scale: Some(1), }), dimension: None, }) diff --git a/crates/polyglot-sql/src/optimizer/annotate_types/engine.rs b/crates/polyglot-sql/src/optimizer/annotate_types/engine.rs new file mode 100644 index 00000000..a97e0775 --- /dev/null +++ b/crates/polyglot-sql/src/optimizer/annotate_types/engine.rs @@ -0,0 +1,1194 @@ +//! DuckDB and PostgreSQL result-type rules. +//! +//! These rules are replayed against engine-recorded result types in +//! `tests/engine_type_truth.rs`. Where the engine type depends on values or on +//! overloads that are not modelled, the rules return no type rather than a +//! plausible concrete type. + +use super::{double_type, duckdb_unsigned_integer_coercion, integer_shape, TypeAnnotator}; +use crate::dialects::DialectType; +use crate::expressions::{DataType, Expression, Function, Literal}; +use crate::optimizer::set_operation_types::common_type; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub(super) enum Engine { + DuckDb, + Postgres, +} + +impl Engine { + pub(super) fn of(dialect: Option) -> Option { + match dialect { + Some(DialectType::DuckDB) => Some(Self::DuckDb), + Some(DialectType::PostgreSQL) => Some(Self::Postgres), + _ => None, + } + } + + fn dialect(self) -> DialectType { + match self { + Self::DuckDb => DialectType::DuckDB, + Self::Postgres => DialectType::PostgreSQL, + } + } + + fn string(self) -> DataType { + match self { + Self::DuckDb => DataType::VarChar { + length: None, + parenthesized_length: false, + }, + Self::Postgres => DataType::Text, + } + } + + /// Result type of the session-identity functions (`CURRENT_USER`, ...). + fn identity(self) -> DataType { + match self { + Self::DuckDb => self.string(), + Self::Postgres => DataType::Custom { + name: "NAME".to_string(), + }, + } + } + + /// Resolve declared-type shorthands to the type the engine stores. + pub(super) fn declared(self, data_type: DataType) -> DataType { + match (self, data_type) { + (Self::DuckDb, DataType::Decimal { precision, scale }) => DataType::Decimal { + precision: Some(precision.unwrap_or(18)), + scale: Some(scale.unwrap_or(if precision.is_some() { 0 } else { 3 })), + }, + ( + Self::Postgres, + DataType::Float { + precision, + scale: None, + real_spelling, + }, + ) => { + if real_spelling || precision.is_some_and(|p| p <= 24) { + real() + } else { + double_type() + } + } + (_, other) => other, + } + } +} + +/// Numeric operand shape shared by arithmetic and unification rules. +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +enum Num { + Int(u16, bool), + Dec(u32, u32), + Real, + Double, +} + +fn real() -> DataType { + DataType::Float { + precision: None, + scale: None, + real_spelling: true, + } +} + +fn numeric() -> DataType { + DataType::Decimal { + precision: None, + scale: None, + } +} + +fn decimal(precision: u32, scale: u32) -> DataType { + DataType::Decimal { + precision: Some(precision), + scale: Some(scale), + } +} + +fn bigint() -> DataType { + DataType::BigInt { length: None } +} + +fn int() -> DataType { + DataType::Int { + length: None, + integer_spelling: false, + } +} + +fn timestamp(timezone: bool) -> DataType { + DataType::Timestamp { + precision: None, + timezone, + } +} + +fn time(timezone: bool) -> DataType { + DataType::Time { + precision: None, + timezone, + } +} + +fn interval() -> DataType { + DataType::Interval { + unit: None, + to: None, + } +} + +fn int_type(bits: u16, unsigned: bool) -> DataType { + match (bits, unsigned) { + (8, false) => DataType::TinyInt { length: None }, + (16, false) => DataType::SmallInt { length: None }, + (32, false) => int(), + (64, false) => bigint(), + (128, false) => DataType::Int128, + (8, true) => DataType::UInt8, + (16, true) => DataType::UInt16, + (32, true) => DataType::UInt32, + (64, true) => DataType::UInt64, + _ => DataType::UInt128, + } +} + +fn num(engine: Engine, data_type: &DataType) -> Option { + if let Some((bits, unsigned)) = integer_shape(data_type) { + return (bits > 0 && (engine == Engine::DuckDb || !unsigned)) + .then_some(Num::Int(bits, unsigned)); + } + match (engine, engine.declared(data_type.clone())) { + (_, DataType::Decimal { precision, scale }) => { + Some(Num::Dec(precision.unwrap_or(0), scale.unwrap_or(0))) + } + ( + Engine::DuckDb, + DataType::Float { + precision: None, .. + }, + ) => Some(Num::Real), + (Engine::Postgres, DataType::Float { .. }) => Some(Num::Real), + (_, DataType::Double { .. }) => Some(Num::Double), + _ => None, + } +} + +fn is_binary(data_type: &DataType) -> bool { + matches!( + data_type, + DataType::Binary { .. } | DataType::VarBinary { .. } | DataType::Blob + ) +} + +fn is_string(data_type: &DataType) -> bool { + matches!( + data_type, + DataType::Char { .. } + | DataType::VarChar { .. } + | DataType::String { .. } + | DataType::Text + | DataType::TextWithLength { .. } + ) +} + +fn unwrap(mut expr: &Expression) -> &Expression { + loop { + expr = match expr { + Expression::Paren(p) => &p.this, + Expression::Annotated(a) => &a.this, + _ => return expr, + }; + } +} + +/// Value of an integer literal, including a negated or parenthesized one. +fn integer_literal(expr: &Expression) -> Option { + match unwrap(expr) { + Expression::Literal(lit) => match lit.as_ref() { + Literal::Number(n) if !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit()) => { + n.parse().ok() + } + _ => None, + }, + Expression::Neg(op) => integer_literal(&op.this).map(|v| -v), + _ => None, + } +} + +fn is_string_literal(expr: &Expression) -> bool { + matches!(unwrap(expr), Expression::Literal(lit) if lit.is_string()) +} + +fn is_null(expr: &Expression) -> bool { + matches!(unwrap(expr), Expression::Null(_)) +} + +fn fits(value: i128, bits: u16, unsigned: bool) -> bool { + if unsigned { + value >= 0 && (bits >= 128 || value < (1i128 << bits)) + } else if bits >= 128 { + true + } else { + let limit = 1i128 << (bits - 1); + value >= -limit && value < limit + } +} + +/// Type of a literal as bound by the engine. +pub(super) fn literal_type(engine: Engine, lit: &Literal) -> Option { + let Literal::Number(text) = lit else { + return match lit { + Literal::String(_) + | Literal::NationalString(_) + | Literal::EscapeString(_) + | Literal::DollarString(_) + | Literal::TripleQuotedString(_, _) + | Literal::RawString(_) => Some(engine.string()), + _ => TypeAnnotator::annotate_literal(lit), + }; + }; + if text.contains(['e', 'E']) { + return Some(match engine { + Engine::DuckDb => double_type(), + Engine::Postgres => numeric(), + }); + } + if let Some((whole, fraction)) = text.split_once('.') { + if !whole + .bytes() + .chain(fraction.bytes()) + .all(|b| b.is_ascii_digit()) + { + return None; + } + return match engine { + Engine::Postgres => Some(numeric()), + Engine::DuckDb => { + let scale = fraction.len() as u32; + let precision = (whole.len() + fraction.len()) as u32; + (precision <= 38).then(|| decimal(precision.max(scale).max(1), scale)) + } + }; + } + let value: i128 = text.parse().ok()?; + Some(if fits(value, 32, false) { + int() + } else if fits(value, 64, false) { + bigint() + } else { + match engine { + Engine::DuckDb => DataType::Int128, + Engine::Postgres => numeric(), + } + }) +} + +/// DuckDB converts integers to DECIMAL(width, 0) before decimal arithmetic. +fn duckdb_decimal_shape(value: Num) -> Option<(u32, u32)> { + match value { + Num::Dec(p, s) => Some((p, s)), + Num::Int(8, _) => Some((3, 0)), + Num::Int(16, _) => Some((5, 0)), + Num::Int(32, _) => Some((10, 0)), + Num::Int(64, false) => Some((19, 0)), + Num::Int(64, true) => Some((20, 0)), + Num::Int(_, _) => Some((38, 0)), + _ => None, + } +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub(super) enum ArithOp { + Add, + Sub, + Mul, + Div, + Mod, + IntDiv, +} + +/// Numeric arithmetic. `None` means the engine result is not modelled. +fn numeric_arithmetic( + engine: Engine, + op: ArithOp, + (left, left_type, left_literal): (Num, &DataType, Option), + (right, right_type, right_literal): (Num, &DataType, Option), +) -> Option { + if matches!(left, Num::Real | Num::Double) || matches!(right, Num::Real | Num::Double) { + return match engine { + Engine::Postgres if op == ArithOp::Mod => None, + Engine::Postgres if left == Num::Real && right == Num::Real => Some(real()), + Engine::Postgres => Some(double_type()), + Engine::DuckDb if left == Num::Double || right == Num::Double => Some(double_type()), + Engine::DuckDb => Some(real()), + }; + } + if engine == Engine::Postgres { + return match (left, right) { + (Num::Int(l, _), Num::Int(r, _)) if op != ArithOp::IntDiv => { + Some(int_type(l.max(r), false)) + } + _ if op != ArithOp::IntDiv => Some(numeric()), + _ => None, + }; + } + // DuckDB `/` always binds the DOUBLE overload for exact numeric inputs. + if op == ArithOp::Div { + return Some(double_type()); + } + if let (Num::Int(lb, lu), Num::Int(rb, ru)) = (left, right) { + // Integer literals adopt the other operand's integer type when they fit. + match (left_literal, right_literal) { + (None, Some(value)) if fits(value, lb, lu) => return Some(left_type.clone()), + (Some(value), None) if fits(value, rb, ru) => return Some(right_type.clone()), + _ => {} + } + return duckdb_unsigned_integer_coercion(left_type, right_type, true) + .or_else(|| Some(int_type(lb.max(rb), false))); + } + if op == ArithOp::IntDiv { + return Some(double_type()); + } + let (lp, ls) = duckdb_decimal_shape(left)?; + let (rp, rs) = duckdb_decimal_shape(right)?; + let max_width = lp.max(rp); + let max_scale = ls.max(rs); + let over_scale = (lp - ls).max(rp - rs); + match op { + ArithOp::Add | ArithOp::Sub => { + let mut width = (max_scale + over_scale).max(max_width) + 1; + if width > 18 && max_width <= 18 { + width = 18; + } + Some(decimal(width.min(38), max_scale)) + } + ArithOp::Mul => { + let scale = ls + rs; + if scale > 38 { + return None; + } + let mut width = lp + rp; + if width > 18 && max_width <= 18 && scale < 18 { + width = 18; + } + Some(decimal(width.min(38), scale)) + } + ArithOp::Mod => { + let width = (max_scale + over_scale).max(max_width); + Some(if width > 38 { + double_type() + } else { + decimal(width, max_scale) + }) + } + ArithOp::Div | ArithOp::IntDiv => None, + } +} + +/// Date/time arithmetic overloads verified against both engines. +fn temporal_arithmetic( + engine: Engine, + op: ArithOp, + left: &DataType, + right: &DataType, +) -> Option { + use DataType::{Date, Interval, Time, Timestamp}; + let duck = engine == Engine::DuckDb; + let date_offset = |t: &DataType| match num(engine, t) { + Some(Num::Int(bits, _)) => duck || bits <= 32, + _ => false, + }; + let numeric_value = |t: &DataType| num(engine, t).is_some(); + match op { + ArithOp::Add => match (left, right) { + (Date, other) | (other, Date) if date_offset(other) => Some(Date), + (Date, Interval { .. }) | (Interval { .. }, Date) => Some(timestamp(false)), + (Timestamp { timezone, .. }, Interval { .. }) + | (Interval { .. }, Timestamp { timezone, .. }) => Some(timestamp(*timezone)), + (Time { timezone, .. }, Interval { .. }) | (Interval { .. }, Time { timezone, .. }) + if duck || !*timezone => + { + Some(time(*timezone)) + } + ( + Date, + Time { + timezone: false, .. + }, + ) + | ( + Time { + timezone: false, .. + }, + Date, + ) => Some(timestamp(false)), + (Interval { .. }, Interval { .. }) => Some(interval()), + _ => None, + }, + ArithOp::Sub => match (left, right) { + (Date, other) if date_offset(other) => Some(Date), + (Date, Date) => Some(if duck { bigint() } else { int() }), + (Date, Interval { .. }) => Some(timestamp(false)), + (Timestamp { timezone, .. }, Interval { .. }) => Some(timestamp(*timezone)), + (Timestamp { timezone: l, .. }, Timestamp { timezone: r, .. }) if l == r => { + Some(interval()) + } + ( + Date, + Timestamp { + timezone: false, .. + }, + ) + | ( + Timestamp { + timezone: false, .. + }, + Date, + ) => Some(interval()), + ( + Time { + timezone: false, .. + }, + Time { + timezone: false, .. + }, + ) if !duck => Some(interval()), + (Time { timezone, .. }, Interval { .. }) if duck || !*timezone => Some(time(*timezone)), + (Interval { .. }, Interval { .. }) => Some(interval()), + _ => None, + }, + ArithOp::Mul => match (left, right) { + (Interval { .. }, other) | (other, Interval { .. }) if numeric_value(other) => { + Some(interval()) + } + _ => None, + }, + ArithOp::Div => match (left, right) { + (Interval { .. }, other) if numeric_value(other) => Some(interval()), + _ => None, + }, + _ => None, + } +} + +impl TypeAnnotator<'_> { + fn arithmetic( + &mut self, + engine: Engine, + op: ArithOp, + left: &Expression, + right: &Expression, + ) -> Option { + let left_type = self.annotate(left)?; + let right_type = self.annotate(right)?; + let left_type = engine.declared(left_type); + let right_type = engine.declared(right_type); + match (num(engine, &left_type), num(engine, &right_type)) { + (Some(l), Some(r)) => numeric_arithmetic( + engine, + op, + (l, &left_type, integer_literal(left)), + (r, &right_type, integer_literal(right)), + ), + _ => temporal_arithmetic(engine, op, &left_type, &right_type), + } + } + + /// Common type of CASE/COALESCE-style branches. NULL is ignored, untyped + /// string literals adopt the other branches' type, and DuckDB integer + /// literals adopt an integer type they fit. + fn unify<'b>( + &mut self, + engine: Engine, + values: impl IntoIterator, + ) -> Option { + let mut typed: Option = None; + let mut literals = Vec::new(); + let mut string_literal = false; + for value in values { + if is_null(value) { + continue; + } + if is_string_literal(value) { + string_literal = true; + continue; + } + if engine == Engine::DuckDb { + if let Some(literal) = integer_literal(value) { + literals.push(literal); + continue; + } + } + let data_type = engine.declared(self.annotate(value)?); + typed = Some(match typed { + None => data_type, + Some(current) => common_type(¤t, &data_type, engine.dialect(), 0)?, + }); + } + for literal in literals { + let literal_type = + literal_type(engine, &Literal::Number(literal.unsigned_abs().to_string()))?; + typed = Some(match typed { + None => literal_type, + Some(current) => match integer_shape(¤t) { + Some((bits, unsigned)) if bits > 0 && fits(literal, bits, unsigned) => current, + _ => common_type(¤t, &literal_type, engine.dialect(), 0)?, + }, + }); + } + match typed { + Some(data_type) => Some(data_type), + None if string_literal => Some(engine.string()), + None => None, + } + } + + fn nullif( + &mut self, + engine: Engine, + left: &Expression, + right: &Expression, + ) -> Option { + let left_type = engine.declared(self.annotate(left)?); + if engine == Engine::DuckDb { + return Some(left_type); + } + // PostgreSQL resolves the equality operator; the first argument is + // cast when that operator promotes it. + let right_type = engine.declared(self.annotate(right)?); + match (num(engine, &left_type), num(engine, &right_type)) { + (Some(Num::Real | Num::Double), _) => Some(left_type), + (Some(_), Some(Num::Real | Num::Double)) => Some(double_type()), + (Some(Num::Int(..)), Some(Num::Dec(..))) => Some(numeric()), + (Some(_), Some(_)) => Some(left_type), + _ if left_type == right_type => Some(left_type), + _ => None, + } + } + + fn engine_sum(&mut self, engine: Engine, arg: &Expression) -> Option { + if engine == Engine::DuckDb { + return self.annotate_sum(arg); + } + let arg_type = engine.declared(self.annotate(arg)?); + match num(engine, &arg_type) { + Some(Num::Int(bits, _)) if bits <= 32 => Some(bigint()), + Some(Num::Int(..) | Num::Dec(..)) => Some(numeric()), + Some(Num::Real) => Some(real()), + Some(Num::Double) => Some(double_type()), + None if matches!(arg_type, DataType::Interval { .. }) => Some(interval()), + None => None, + } + } + + fn engine_avg(&mut self, engine: Engine, arg: &Expression) -> Option { + let arg_type = engine.declared(self.annotate(arg)?); + match (engine, num(engine, &arg_type)) { + (Engine::DuckDb, Some(_)) => Some(double_type()), + (Engine::Postgres, Some(Num::Int(..) | Num::Dec(..))) => Some(numeric()), + (Engine::Postgres, Some(_)) => Some(double_type()), + (_, None) => match arg_type { + DataType::Interval { .. } => Some(interval()), + DataType::Date if engine == Engine::DuckDb => Some(timestamp(false)), + DataType::Timestamp { .. } | DataType::Time { .. } if engine == Engine::DuckDb => { + Some(arg_type) + } + _ => None, + }, + } + } + + /// STDDEV/VARIANCE family. + fn engine_statistic(&mut self, engine: Engine, arg: &Expression) -> Option { + let arg_type = engine.declared(self.annotate(arg)?); + match (engine, num(engine, &arg_type)?) { + (Engine::Postgres, Num::Int(..) | Num::Dec(..)) => Some(numeric()), + _ => Some(double_type()), + } + } + + /// MIN/MAX. PostgreSQL aggregates drop the input's type modifier. + fn engine_min_max(&mut self, engine: Engine, arg: &Expression) -> Option { + let arg_type = engine.declared(self.annotate(arg)?); + if engine == Engine::DuckDb { + return Some(arg_type); + } + Some(match arg_type { + DataType::Decimal { .. } => numeric(), + DataType::VarChar { .. } => DataType::VarChar { + length: None, + parenthesized_length: false, + }, + DataType::Char { .. } => return None, + DataType::Timestamp { timezone, .. } => timestamp(timezone), + DataType::Time { timezone, .. } => time(timezone), + other => other, + }) + } + + fn engine_round( + &mut self, + engine: Engine, + arg: &Expression, + digits: Option<&Expression>, + ) -> Option { + let arg_type = engine.declared(self.annotate(arg)?); + let value = num(engine, &arg_type)?; + if engine == Engine::Postgres { + return match (value, digits) { + (Num::Int(..) | Num::Real | Num::Double, None) => Some(double_type()), + (Num::Int(..) | Num::Dec(..), _) => Some(numeric()), + _ => None, + }; + } + match value { + Num::Int(bits, false) => Some(int_type(bits, false)), + Num::Int(bits, true) if bits <= 32 => Some(bigint()), + Num::Int(64, true) => Some(DataType::Int128), + Num::Int(..) | Num::Double => Some(double_type()), + Num::Real => Some(real()), + Num::Dec(p, s) => match digits { + None => Some(decimal(p, 0)), + Some(digits) => { + let digits = u32::try_from(integer_literal(digits)?).ok()?; + Some(decimal(p, s.min(digits))) + } + }, + } + } + + fn engine_floor_ceil(&mut self, engine: Engine, arg: &Expression) -> Option { + let arg_type = engine.declared(self.annotate(arg)?); + match (engine, num(engine, &arg_type)?) { + (_, Num::Int(..)) | (_, Num::Double) | (Engine::Postgres, Num::Real) => { + Some(double_type()) + } + (Engine::DuckDb, Num::Real) => Some(real()), + (Engine::DuckDb, Num::Dec(p, _)) => Some(decimal(p, 0)), + (Engine::Postgres, Num::Dec(..)) => Some(numeric()), + } + } + + fn engine_sign(&mut self, engine: Engine, arg: &Expression) -> Option { + let arg_type = engine.declared(self.annotate(arg)?); + match (engine, num(engine, &arg_type)?) { + (Engine::DuckDb, _) => Some(DataType::TinyInt { length: None }), + (Engine::Postgres, Num::Dec(..)) => Some(numeric()), + (Engine::Postgres, _) => Some(double_type()), + } + } + + fn engine_abs(&mut self, engine: Engine, arg: &Expression) -> Option { + let arg_type = engine.declared(self.annotate(arg)?); + match num(engine, &arg_type)? { + Num::Dec(..) if engine == Engine::Postgres => Some(numeric()), + _ => Some(arg_type), + } + } + + /// SQRT/LN/EXP/POWER: PostgreSQL keeps NUMERIC inputs exact. + fn engine_transcendental(&mut self, engine: Engine, args: &[&Expression]) -> Option { + let mut decimal_input = false; + for arg in args { + let arg_type = engine.declared(self.annotate(arg)?); + match num(engine, &arg_type)? { + Num::Real | Num::Double => return Some(double_type()), + Num::Dec(..) => decimal_input = true, + Num::Int(..) => {} + } + } + Some(if engine == Engine::Postgres && decimal_input { + numeric() + } else { + double_type() + }) + } + + fn engine_string_result( + &mut self, + engine: Engine, + input: Option<&Expression>, + ) -> Option { + if let Some(input) = input { + if let Some(input_type) = self.annotate(input) { + if is_binary(&input_type) || matches!(input_type, DataType::Array { .. }) { + return None; + } + } + } + Some(engine.string()) + } + + fn engine_concat(&mut self, engine: Engine, args: &[&Expression]) -> Option { + let mut has_string = false; + let mut all_known = true; + for arg in args { + if is_string_literal(arg) { + has_string = true; + continue; + } + match self.annotate(arg) { + Some(t) + if is_binary(&t) + || matches!( + t, + DataType::Array { .. } + | DataType::List { .. } + | DataType::JsonB + | DataType::Json + ) => + { + return None + } + Some(t) => has_string |= is_string(&t), + None => all_known &= is_null(arg), + } + } + (has_string || (engine == Engine::DuckDb && all_known)).then(|| engine.string()) + } + + fn engine_date_trunc(&mut self, engine: Engine, value: &Expression) -> Option { + match engine.declared(self.annotate(value)?) { + DataType::Date => Some(timestamp(engine == Engine::Postgres)), + DataType::Timestamp { timezone, .. } => Some(timestamp(timezone)), + DataType::Interval { .. } => Some(interval()), + _ => None, + } + } + + fn engine_date_part(&mut self, engine: Engine, field: &Expression) -> Option { + if engine == Engine::Postgres { + return Some(double_type()); + } + let Expression::Literal(lit) = unwrap(field) else { + return None; + }; + let Literal::String(name) = lit.as_ref() else { + return None; + }; + Some( + if name.eq_ignore_ascii_case("epoch") || name.eq_ignore_ascii_case("julian") { + double_type() + } else { + bigint() + }, + ) + } +} + +impl TypeAnnotator<'_> { + /// Returns `Some(result)` when an engine rule owns `expr`; `result` may be + /// `None` when the engine type is not modelled. + pub(super) fn annotate_engine( + &mut self, + engine: Engine, + expr: &Expression, + ) -> Option> { + let duck = engine == Engine::DuckDb; + Some(match expr { + Expression::Literal(lit) => literal_type(engine, lit), + Expression::Add(op) => self.arithmetic(engine, ArithOp::Add, &op.left, &op.right), + Expression::Sub(op) => self.arithmetic(engine, ArithOp::Sub, &op.left, &op.right), + Expression::Mul(op) => self.arithmetic(engine, ArithOp::Mul, &op.left, &op.right), + Expression::Div(op) => self.arithmetic(engine, ArithOp::Div, &op.left, &op.right), + Expression::Mod(op) => self.arithmetic(engine, ArithOp::Mod, &op.left, &op.right), + Expression::ModFunc(f) => self.arithmetic(engine, ArithOp::Mod, &f.this, &f.expression), + Expression::IntDiv(f) if duck => { + self.arithmetic(engine, ArithOp::IntDiv, &f.this, &f.expression) + } + Expression::Neg(op) => { + let data_type = engine.declared(self.annotate(&op.this)?); + match (engine, &data_type) { + (Engine::Postgres, DataType::Decimal { .. }) => Some(numeric()), + (_, DataType::Interval { .. }) => Some(data_type), + _ if num(engine, &data_type).is_some() => Some(data_type), + _ => None, + } + } + Expression::Concat(op) => self.engine_concat(engine, &[&op.left, &op.right]), + Expression::NullSafeEq(_) | Expression::NullSafeNeq(_) => Some(DataType::Boolean), + Expression::Column(_) => self.annotate_default(expr).map(|t| engine.declared(t)), + Expression::Cast(c) | Expression::TryCast(c) | Expression::SafeCast(c) => { + Some(engine.declared(c.to.clone())) + } + Expression::Count(_) => Some(bigint()), + Expression::Sum(agg) => self.engine_sum(engine, &agg.this), + Expression::Avg(agg) => self.engine_avg(engine, &agg.this), + Expression::Min(agg) | Expression::Max(agg) => self.engine_min_max(engine, &agg.this), + Expression::Stddev(agg) + | Expression::StddevPop(agg) + | Expression::StddevSamp(agg) + | Expression::Variance(agg) + | Expression::VarPop(agg) + | Expression::VarSamp(agg) => self.engine_statistic(engine, &agg.this), + Expression::LogicalAnd(_) | Expression::LogicalOr(_) => Some(DataType::Boolean), + Expression::StringAgg(agg) => self.engine_string_result(engine, Some(&agg.this)), + Expression::Case(case) => self.unify( + engine, + case.whens + .iter() + .map(|(_, result)| result) + .chain(case.else_.iter()), + ), + Expression::Coalesce(f) | Expression::Greatest(f) | Expression::Least(f) => { + self.unify(engine, f.expressions.iter()) + } + Expression::IfNull(f) | Expression::Nvl(f) => { + self.unify(engine, [&f.this, &f.expression]) + } + Expression::NullIf(f) => self.nullif(engine, &f.this, &f.expression), + Expression::Round(f) => self.engine_round(engine, &f.this, f.decimals.as_ref()), + Expression::Floor(f) if f.scale.is_none() && f.to.is_none() => { + self.engine_floor_ceil(engine, &f.this) + } + Expression::Ceil(f) if f.decimals.is_none() && f.to.is_none() => { + self.engine_floor_ceil(engine, &f.this) + } + Expression::Floor(_) | Expression::Ceil(_) => None, + Expression::Abs(f) => self.engine_abs(engine, &f.this), + Expression::Sign(f) => self.engine_sign(engine, &f.this), + Expression::Sqrt(f) | Expression::Ln(f) | Expression::Exp(f) => { + self.engine_transcendental(engine, &[&f.this]) + } + Expression::Power(f) => self.engine_transcendental(engine, &[&f.this, &f.expression]), + Expression::Length(_) => Some(if duck { bigint() } else { int() }), + Expression::StrPosition(_) => Some(if duck { bigint() } else { int() }), + Expression::Upper(f) + | Expression::Lower(f) + | Expression::LTrim(f) + | Expression::RTrim(f) + | Expression::Reverse(f) + | Expression::Initcap(f) => self.engine_string_result(engine, Some(&f.this)), + Expression::Trim(f) => self.engine_string_result(engine, Some(&f.this)), + Expression::Substring(f) => self.engine_string_result(engine, Some(&f.this)), + Expression::Replace(f) => self.engine_string_result(engine, Some(&f.this)), + Expression::Left(_) + | Expression::Right(_) + | Expression::Repeat(_) + | Expression::Lpad(_) + | Expression::Rpad(_) + | Expression::ConcatWs(_) => Some(engine.string()), + Expression::ToChar(_) if !duck => Some(DataType::Text), + Expression::Random(_) => Some(double_type()), + Expression::Extract(_) if !duck => Some(numeric()), + Expression::DateTrunc(f) | Expression::TimestampTrunc(f) => { + self.engine_date_trunc(engine, &f.this) + } + Expression::CurrentDate(_) => Some(DataType::Date), + Expression::CurrentTime(_) => Some(time(true)), + Expression::CurrentTimestamp(_) => Some(timestamp(true)), + Expression::Localtime(_) => Some(time(false)), + Expression::Localtimestamp(_) => Some(timestamp(false)), + Expression::CurrentUser(_) + | Expression::SessionUser(_) + | Expression::CurrentSchema(_) => Some(engine.identity()), + Expression::RowNumber(_) | Expression::Rank(_) | Expression::DenseRank(_) => { + Some(bigint()) + } + Expression::Lag(f) | Expression::Lead(f) => { + self.annotate(&f.this).map(|t| engine.declared(t)) + } + Expression::Epoch(_) if duck => Some(double_type()), + Expression::Year(_) + | Expression::Month(_) + | Expression::Day(_) + | Expression::Hour(_) + | Expression::Minute(_) + | Expression::Second(_) + if duck => + { + Some(bigint()) + } + Expression::Uuid(_) => Some(DataType::Uuid), + Expression::Function(func) => self.annotate_engine_function(engine, func)?, + _ => return None, + }) + } + + /// Named-function rules. Recognized names return `Some` even when the + /// arguments are missing, so relation outputs treat them as modelled. + pub(super) fn annotate_engine_function( + &mut self, + engine: Engine, + func: &Function, + ) -> Option> { + if func.quoted { + return None; + } + let duck = engine == Engine::DuckDb; + let args = &func.args; + let first = args.first(); + let name = func.name.to_ascii_uppercase(); + Some(match name.as_str() { + "COUNT" => Some(bigint()), + "SUM" => first.and_then(|a| self.engine_sum(engine, a)), + "AVG" => first.and_then(|a| self.engine_avg(engine, a)), + "MIN" | "MAX" if args.len() == 1 => first.and_then(|a| self.engine_min_max(engine, a)), + "STDDEV" | "STDDEV_SAMP" | "STDDEV_POP" | "VARIANCE" | "VAR_SAMP" | "VAR_POP" => { + first.and_then(|a| self.engine_statistic(engine, a)) + } + "BOOL_AND" | "BOOL_OR" | "EVERY" => Some(DataType::Boolean), + "ROUND" if args.len() <= 2 => { + first.and_then(|a| self.engine_round(engine, a, args.get(1))) + } + "ABS" => first.and_then(|a| self.engine_abs(engine, a)), + "FLOOR" | "CEIL" | "CEILING" if args.len() <= 1 => { + first.and_then(|a| self.engine_floor_ceil(engine, a)) + } + "SIGN" => first.and_then(|a| self.engine_sign(engine, a)), + "SQRT" | "LN" | "EXP" | "POWER" | "POW" if !args.is_empty() => { + let args: Vec<_> = args.iter().collect(); + self.engine_transcendental(engine, &args) + } + "MOD" if args.len() == 2 => self.arithmetic(engine, ArithOp::Mod, &args[0], &args[1]), + "LENGTH" | "CHAR_LENGTH" | "CHARACTER_LENGTH" | "STRPOS" => { + Some(if duck { bigint() } else { int() }) + } + "UPPER" | "LOWER" | "TRIM" | "LTRIM" | "RTRIM" | "REPLACE" | "SUBSTRING" | "SUBSTR" + | "LEFT" | "RIGHT" | "REVERSE" | "REPEAT" | "LPAD" | "RPAD" | "INITCAP" | "MD5" => { + self.engine_string_result(engine, first) + } + "STRING_AGG" => self.engine_string_result(engine, first), + "CONCAT" | "CONCAT_WS" if !duck => Some(DataType::Text), + "CONCAT" => { + let args: Vec<_> = args.iter().collect(); + self.engine_concat(engine, &args) + } + "CONCAT_WS" => Some(engine.string()), + "TO_CHAR" if !duck => Some(DataType::Text), + "STRFTIME" | "DAYNAME" | "MONTHNAME" if duck => Some(engine.string()), + "NOW" | "CURRENT_TIMESTAMP" | "TRANSACTION_TIMESTAMP" => Some(timestamp(true)), + "GET_CURRENT_TIMESTAMP" if duck => Some(timestamp(true)), + "STATEMENT_TIMESTAMP" | "CLOCK_TIMESTAMP" if !duck => Some(timestamp(true)), + "CURRENT_TIME" => Some(time(true)), + "LOCALTIME" => Some(time(false)), + "LOCALTIMESTAMP" => Some(timestamp(false)), + "CURRENT_DATE" => Some(DataType::Date), + "TODAY" if duck => Some(DataType::Date), + "USER" | "CURRENT_USER" | "SESSION_USER" | "CURRENT_ROLE" | "CURRENT_SCHEMA" + | "CURRENT_CATALOG" | "CURRENT_DATABASE" + if args.is_empty() => + { + Some(engine.identity()) + } + "GEN_RANDOM_UUID" => Some(DataType::Uuid), + "UUID" if duck => Some(DataType::Uuid), + "RANDOM" => Some(double_type()), + "DATE_TRUNC" if args.len() == 2 => self.engine_date_trunc(engine, &args[1]), + "DATE_PART" if args.len() == 2 => self.engine_date_part(engine, &args[0]), + "AGE" if !duck => Some(interval()), + "EPOCH" if duck => Some(double_type()), + "YEAR" | "MONTH" | "DAY" | "HOUR" | "MINUTE" | "SECOND" if duck => Some(bigint()), + "NULLIF" if args.len() == 2 => self.nullif(engine, &args[0], &args[1]), + "COALESCE" | "GREATEST" | "LEAST" => self.unify(engine, args.iter()), + "IFNULL" if duck => self.unify(engine, args.iter()), + "LIST_VALUE" | "LIST_PACK" if duck => { + self.unify(engine, args.iter()) + .map(|element_type| DataType::Array { + element_type: Box::new(element_type), + dimension: None, + }) + } + "ROW_NUMBER" | "RANK" | "DENSE_RANK" => Some(bigint()), + "LAG" | "LEAD" | "FIRST_VALUE" | "LAST_VALUE" => first + .and_then(|a| self.annotate(a)) + .map(|t| engine.declared(t)), + _ => return None, + }) + } +} + +#[cfg(test)] +mod tests { + use crate::expressions::{DataType, Expression}; + use crate::optimizer::annotate_types::annotate_types; + use crate::{parse_one, DialectType, MappingSchema, Schema}; + + fn projection_type(sql: &str, dialect: DialectType) -> Option { + let mut schema = MappingSchema::with_dialect(dialect); + let columns = [ + ("quantity", "INTEGER"), + ("line_count", "BIGINT"), + ("unit_price", "DECIMAL(9,2)"), + ("weight", "DOUBLE PRECISION"), + ]; + let columns: Vec<_> = columns + .iter() + .map(|(name, ty)| { + let Expression::Cast(cast) = + parse_one(&format!("CAST(NULL AS {ty})"), dialect).unwrap() + else { + panic!("cast") + }; + (name.to_string(), cast.to) + }) + .collect(); + schema.add_table("orders", &columns, Some(dialect)).unwrap(); + let mut expression = parse_one(sql, dialect).unwrap(); + annotate_types(&mut expression, Some(&schema), Some(dialect)); + let Expression::Select(select) = expression else { + panic!("select") + }; + select.expressions[0].inferred_type().cloned() + } + + fn double() -> DataType { + DataType::Double { + precision: None, + scale: None, + } + } + + #[test] + fn duckdb_division_always_binds_double() { + for expr in [ + "SUM(quantity) / COUNT(*)", + "7 / 2", + "quantity / line_count", + "unit_price / unit_price", + "CAST(10 AS HUGEINT) / 2", + "line_count / 2", + ] { + let sql = format!("SELECT {expr} AS v FROM orders"); + assert_eq!( + projection_type(&sql, DialectType::DuckDB), + Some(double()), + "{expr}" + ); + } + } + + #[test] + fn duckdb_integer_division_and_postgres_division_stay_integral() { + let sql = "SELECT quantity // 2 AS v FROM orders"; + assert!(matches!( + projection_type(sql, DialectType::DuckDB), + Some(DataType::Int { .. }) + )); + let sql = "SELECT line_count // quantity AS v FROM orders"; + assert!(matches!( + projection_type(sql, DialectType::DuckDB), + Some(DataType::BigInt { .. }) + )); + let sql = "SELECT SUM(quantity) / COUNT(*) AS v FROM orders"; + assert!(matches!( + projection_type(sql, DialectType::PostgreSQL), + Some(DataType::BigInt { .. }) + )); + let sql = "SELECT unit_price / 2 AS v FROM orders"; + assert_eq!( + projection_type(sql, DialectType::PostgreSQL), + Some(DataType::Decimal { + precision: None, + scale: None + }) + ); + } + + #[test] + fn duckdb_integer_division_round_trips() { + let expression = + parse_one("SELECT quantity // 2 FROM orders", DialectType::DuckDB).unwrap(); + assert_eq!( + crate::generate(&expression, DialectType::DuckDB).unwrap(), + "SELECT quantity // 2 FROM orders" + ); + } + + #[test] + fn bare_niladic_keywords_are_typed_functions() { + let varchar = DataType::VarChar { + length: None, + parenthesized_length: false, + }; + let name = DataType::Custom { + name: "NAME".into(), + }; + for keyword in [ + "USER", + "CURRENT_USER", + "SESSION_USER", + "CURRENT_ROLE", + "CURRENT_SCHEMA", + "CURRENT_CATALOG", + ] { + let sql = format!("SELECT {keyword} AS v FROM orders"); + assert_eq!( + projection_type(&sql, DialectType::DuckDB), + Some(varchar.clone()), + "{keyword}" + ); + assert_eq!( + projection_type(&sql, DialectType::PostgreSQL), + Some(name.clone()), + "{keyword}" + ); + } + for dialect in [DialectType::DuckDB, DialectType::PostgreSQL] { + let typed = |keyword: &str| { + projection_type(&format!("SELECT {keyword} AS v FROM orders"), dialect) + }; + assert_eq!(typed("CURRENT_DATE"), Some(DataType::Date)); + assert_eq!( + typed("CURRENT_TIMESTAMP"), + Some(DataType::Timestamp { + precision: None, + timezone: true + }) + ); + assert_eq!( + typed("LOCALTIMESTAMP"), + Some(DataType::Timestamp { + precision: None, + timezone: false + }) + ); + assert_eq!( + typed("LOCALTIME"), + Some(DataType::Time { + precision: None, + timezone: false + }) + ); + } + } + + #[test] + fn bare_user_stays_a_column_where_it_is_not_a_keyword() { + for dialect in [DialectType::DuckDB, DialectType::PostgreSQL] { + for sql in [ + "SELECT orders.user FROM orders", + "SELECT \"user\" FROM orders", + ] { + let Expression::Select(select) = parse_one(sql, dialect).unwrap() else { + panic!("select") + }; + assert!( + matches!(select.expressions[0], Expression::Column(_)), + "{sql}" + ); + } + } + let Expression::Select(select) = + parse_one("SELECT user FROM orders", DialectType::MySQL).unwrap() + else { + panic!("select") + }; + assert!(matches!(select.expressions[0], Expression::Column(_))); + } + + #[test] + fn unmodelled_values_are_unknown_not_guessed() { + for sql in [ + "SELECT unknown_udf(quantity) AS v FROM orders", + "SELECT quantity + missing_column AS v FROM orders", + "SELECT unit_price % CAST(1 AS HUGEINT) + unknown_udf(1) AS v FROM orders", + ] { + assert_eq!(projection_type(sql, DialectType::DuckDB), None, "{sql}"); + } + } +} diff --git a/crates/polyglot-sql/src/optimizer/set_operation_types.rs b/crates/polyglot-sql/src/optimizer/set_operation_types.rs index c9d26b4b..99025b03 100644 --- a/crates/polyglot-sql/src/optimizer/set_operation_types.rs +++ b/crates/polyglot-sql/src/optimizer/set_operation_types.rs @@ -279,7 +279,7 @@ fn inferred_output(expr: &Expression, inner: &Expression, dialect: DialectType) return OutputType::Unknown; } if let Expression::Literal(literal) = inner { - return super::annotate_types::TypeAnnotator::annotate_literal(literal) + return super::annotate_types::TypeAnnotator::annotate_literal_for(literal, Some(dialect)) .map(|t| OutputType::Known(canonical(&t, dialect))) .unwrap_or(OutputType::Unknown); } diff --git a/crates/polyglot-sql/src/parser.rs b/crates/polyglot-sql/src/parser.rs index 9af1ab4e..8142778d 100644 --- a/crates/polyglot-sql/src/parser.rs +++ b/crates/polyglot-sql/src/parser.rs @@ -30406,6 +30406,14 @@ impl Parser { let expr = if self.match_token(TokenType::Star) { let right = self.parse_power()?; Expression::Mul(Box::new(BinaryOp::new(left, right))) + } else if self.match_duckdb_integer_division() { + let right = self.parse_power()?; + Expression::IntDiv(Box::new(crate::expressions::BinaryFunc { + this: left, + expression: right, + original_name: None, + inferred_type: None, + })) } else if self.match_token(TokenType::Slash) { let right = self.parse_power()?; Expression::Div(Box::new(BinaryOp::new(left, right))) @@ -30692,6 +30700,19 @@ impl Parser { Ok(expr) } + /// DuckDB's `//` integer-division operator is tokenized as two adjacent slashes. + fn match_duckdb_integer_division(&mut self) -> bool { + if self.config.dialect != Some(crate::dialects::DialectType::DuckDB) + || !self.check(TokenType::Slash) + || !self.check_next(TokenType::Slash) + || self.tokens[self.current].span.end != self.tokens[self.current + 1].span.start + { + return false; + } + self.current += 2; + true + } + /// Parse multiplication/division #[inline(always)] fn parse_multiplication(&mut self) -> Result { @@ -30705,6 +30726,14 @@ impl Parser { let expr = if self.match_token(TokenType::Star) { let right = self.parse_power()?; Expression::Mul(Box::new(BinaryOp::new(left, right))) + } else if self.match_duckdb_integer_division() { + let right = self.parse_power()?; + Expression::IntDiv(Box::new(crate::expressions::BinaryFunc { + this: left, + expression: right, + original_name: None, + inferred_type: None, + })) } else if self.match_token(TokenType::Slash) { let right = self.parse_power()?; Expression::Div(Box::new(BinaryOp::new(left, right))) @@ -32433,7 +32462,10 @@ impl Parser { let upper_name = self.peek_text().to_ascii_uppercase(); if !self.check_next(TokenType::LParen) && !self.check_next(TokenType::Dot) - && crate::function_registry::is_no_paren_function_name_upper(upper_name.as_str()) + && (crate::function_registry::is_no_paren_function_name_upper(upper_name.as_str()) + || (upper_name == "USER" + && self.peek().token_type != TokenType::QuotedIdentifier + && crate::function_registry::bare_user_is_function(self.config.dialect))) && !(matches!( self.config.dialect, Some(crate::dialects::DialectType::ClickHouse) diff --git a/crates/polyglot-sql/src/validation/coercion.rs b/crates/polyglot-sql/src/validation/coercion.rs index a07b61ed..a0991f2e 100644 --- a/crates/polyglot-sql/src/validation/coercion.rs +++ b/crates/polyglot-sql/src/validation/coercion.rs @@ -286,6 +286,15 @@ pub(super) fn arithmetic( if (add && ADD.contains(&(left, right))) || (sub && SUB.contains(&(left, right))) { return true; } + // Engine-verified DuckDB/PostgreSQL overloads: DATE + TIME builds a + // timestamp and mixed DATE/TIMESTAMP subtraction yields an interval. + if matches!(dialect, DialectType::DuckDB | DialectType::PostgreSQL) + && ((add && matches!((left, right), (Date, Time) | (Time, Date))) + || (sub && matches!((left, right), (Date, Timestamp) | (Timestamp, Date))) + || (sub && dialect == DialectType::PostgreSQL && (left, right) == (Time, Time))) + { + return true; + } // Snowflake permits numeric VARCHAR arithmetic; do not reject uncertain // overloads on other engines based on DuckDB's binder. dialect == DialectType::Snowflake diff --git a/crates/polyglot-sql/tests/engine_type_truth.rs b/crates/polyglot-sql/tests/engine_type_truth.rs new file mode 100644 index 00000000..1d06e0c6 --- /dev/null +++ b/crates/polyglot-sql/tests/engine_type_truth.rs @@ -0,0 +1,292 @@ +//! Replays engine-recorded DuckDB and PostgreSQL result types. +//! +//! The fixtures under `tests/fixtures/engine_types` were produced by +//! `tools/engine-type-truth/generate.py`, which asks the real engines for the +//! bound type of every synthetic expression. Polyglot must report the same type +//! or no type at all; a wrong concrete type becomes a false schema change in +//! downstream consumers. Unknown results are accepted only where listed in +//! [`DOCUMENTED_UNKNOWNS`], and engine-valid SQL must never fail validation. + +use std::collections::BTreeMap; + +use polyglot_sql::{ + analyze_query, compile_required_query_analysis, validate_with_schema, AnalyzeQueryOptions, + DialectType, SchemaValidationOptions, ValidationSchema, ValidationSeverity, +}; + +#[derive(serde::Deserialize)] +struct Fixture { + engine: String, + schema: ValidationSchema, + cases: Vec, +} + +#[derive(serde::Deserialize)] +struct Case { + id: String, + category: String, + sql: String, + #[serde(rename = "type")] + engine_type: Option, +} + +/// Engine types that Polyglot deliberately leaves unknown, with the reason. +/// Entries match a case ID prefix within one engine. +const DOCUMENTED_UNKNOWNS: &[(&str, &str, &str)] = &[]; + +fn canonical_duckdb(raw: &str) -> String { + let upper = raw.trim().to_ascii_uppercase().replace(", ", ","); + if let Some(element) = upper.strip_suffix("[]") { + return format!("{}[]", canonical_duckdb(element)); + } + let (base, params) = match upper.split_once('(') { + Some((base, rest)) => ( + base.trim().to_string(), + Some(rest.trim_end_matches(')').to_string()), + ), + None => (upper.clone(), None), + }; + match base.as_str() { + "DECIMAL" | "NUMERIC" | "DEC" => match params.as_deref() { + None => "DECIMAL(18,3)".into(), + Some(p) if !p.contains(',') => format!("DECIMAL({p},0)"), + Some(p) => format!("DECIMAL({p})"), + }, + "TINYINT" | "INT1" => "TINYINT".into(), + "SMALLINT" | "INT2" | "SHORT" => "SMALLINT".into(), + "INTEGER" | "INT" | "INT4" | "SIGNED" => "INTEGER".into(), + "BIGINT" | "INT8" | "LONG" => "BIGINT".into(), + "HUGEINT" | "INT128" => "HUGEINT".into(), + "UTINYINT" | "UINT8" => "UTINYINT".into(), + "USMALLINT" | "UINT16" => "USMALLINT".into(), + "UINTEGER" | "UINT32" => "UINTEGER".into(), + "UBIGINT" | "UINT64" => "UBIGINT".into(), + "UHUGEINT" | "UINT128" => "UHUGEINT".into(), + "FLOAT" | "FLOAT4" | "REAL" => "FLOAT".into(), + "DOUBLE" | "FLOAT8" | "DOUBLE PRECISION" => "DOUBLE".into(), + "VARCHAR" | "TEXT" | "STRING" | "CHAR" | "BPCHAR" | "CHARACTER VARYING" => "VARCHAR".into(), + "BOOLEAN" | "BOOL" => "BOOLEAN".into(), + "TIMESTAMP" | "DATETIME" | "TIMESTAMP WITHOUT TIME ZONE" => "TIMESTAMP".into(), + "TIMESTAMPTZ" | "TIMESTAMP WITH TIME ZONE" => "TIMESTAMPTZ".into(), + "TIME" | "TIME WITHOUT TIME ZONE" => "TIME".into(), + "TIMETZ" | "TIME WITH TIME ZONE" => "TIMETZ".into(), + "BLOB" | "BYTEA" | "VARBINARY" => "BLOB".into(), + _ => match params { + Some(p) => format!("{base}({p})"), + None => base, + }, + } +} + +fn canonical_postgres(raw: &str) -> String { + let upper = raw.trim().to_ascii_uppercase().replace(", ", ","); + if let Some(element) = upper.strip_suffix("[]") { + return format!("{}[]", canonical_postgres(element)); + } + let (base, params) = match upper.split_once('(') { + Some((base, rest)) => { + let (params, suffix) = rest.split_once(')').unwrap_or((rest, "")); + ( + format!("{}{}", base.trim(), suffix).trim().to_string(), + Some(params.to_string()), + ) + } + None => (upper.clone(), None), + }; + let with_params = |name: &str| match ¶ms { + Some(p) => format!("{name}({p})"), + None => name.to_string(), + }; + match base.as_str() { + "SMALLINT" | "INT2" => "SMALLINT".into(), + "INTEGER" | "INT" | "INT4" => "INTEGER".into(), + "BIGINT" | "INT8" => "BIGINT".into(), + "NUMERIC" | "DECIMAL" => match params.as_deref() { + Some(p) if !p.contains(',') => format!("NUMERIC({p},0)"), + _ => with_params("NUMERIC"), + }, + "REAL" | "FLOAT4" => "REAL".into(), + "DOUBLE PRECISION" | "FLOAT8" | "DOUBLE" => "DOUBLE PRECISION".into(), + "FLOAT" => match params.as_deref().map(str::parse::) { + Some(Ok(bits)) if bits <= 24 => "REAL".into(), + _ => "DOUBLE PRECISION".into(), + }, + "TEXT" => "TEXT".into(), + "VARCHAR" | "CHARACTER VARYING" => with_params("VARCHAR"), + "CHAR" | "CHARACTER" | "BPCHAR" => with_params("CHAR"), + "BOOLEAN" | "BOOL" => "BOOLEAN".into(), + "TIMESTAMP" | "TIMESTAMP WITHOUT TIME ZONE" => "TIMESTAMP".into(), + "TIMESTAMPTZ" | "TIMESTAMP WITH TIME ZONE" => "TIMESTAMPTZ".into(), + "TIME" | "TIME WITHOUT TIME ZONE" => "TIME".into(), + "TIMETZ" | "TIME WITH TIME ZONE" => "TIMETZ".into(), + _ => with_params(&base), + } +} + +#[derive(Default)] +struct Tally { + compared: usize, + exact: usize, + documented_unknown: usize, + failures: BTreeMap>, +} + +fn replay(fixture_json: &str, dialect: DialectType) -> Tally { + let fixture: Fixture = serde_json::from_str(fixture_json).unwrap(); + let canonical: fn(&str) -> String = match dialect { + DialectType::DuckDB => canonical_duckdb, + _ => canonical_postgres, + }; + let sqlbuild_validation = SchemaValidationOptions { + check_types: false, + check_references: true, + strict: Some(true), + semantic: false, + strict_syntax: false, + ..Default::default() + }; + let semantic_validation = SchemaValidationOptions { + check_types: true, + check_references: true, + strict: Some(true), + semantic: true, + ..Default::default() + }; + let options = AnalyzeQueryOptions { + dialect, + schema: Some(fixture.schema.clone()), + ..Default::default() + }; + let mut tally = Tally::default(); + for case in &fixture.cases { + let Some(engine_type) = case.engine_type.as_deref() else { + continue; + }; + tally.compared += 1; + let expected = canonical(engine_type); + let mut record = |kind: &str, detail: String| { + tally + .failures + .entry(format!("{} {kind}", case.category)) + .or_default() + .push(format!("{}: {detail}", case.id)); + }; + + let compiled = compile_required_query_analysis( + &case.sql, + options.clone(), + &fixture.schema, + &sqlbuild_validation, + true, + ); + let errors: Vec<_> = compiled + .validation + .errors + .iter() + .filter(|error| error.severity == ValidationSeverity::Error) + .map(|error| format!("{} {}", error.code, error.message)) + .collect(); + if !errors.is_empty() { + record("validation", format!("{errors:?}")); + } + let semantic = + validate_with_schema(&case.sql, dialect, &fixture.schema, &semantic_validation); + let semantic_errors: Vec<_> = semantic + .errors + .iter() + .filter(|error| error.severity == ValidationSeverity::Error) + .map(|error| format!("{} {}", error.code, error.message)) + .collect(); + if !semantic_errors.is_empty() { + record("semantic validation", format!("{semantic_errors:?}")); + } + + let project_type = compiled.analysis.ok().and_then(|analysis| { + analysis + .projections + .first() + .and_then(|p| p.type_hint.clone()) + }); + let default_type = analyze_query(&case.sql, options.clone()) + .ok() + .and_then(|analysis| { + analysis + .projections + .first() + .and_then(|p| p.type_hint.clone()) + }); + + let mut unknown = false; + let mut wrong = Vec::new(); + for (path, reported) in [("project", &project_type), ("analysis", &default_type)] { + match reported.as_deref().map(canonical) { + None => unknown = true, + Some(actual) if actual == "UNKNOWN" => unknown = true, + Some(actual) if actual == expected => {} + Some(actual) => wrong.push(format!("{path} {actual}")), + } + } + if !wrong.is_empty() { + record( + "wrong type", + format!("{} != engine {expected}", wrong.join(", ")), + ); + continue; + } + if unknown { + if let Some((_, _, _)) = DOCUMENTED_UNKNOWNS.iter().find(|(engine, prefix, _)| { + *engine == fixture.engine && case.id.starts_with(prefix) + }) { + tally.documented_unknown += 1; + } else { + record("unknown", format!("engine {expected}")); + } + } else { + tally.exact += 1; + } + } + tally +} + +fn assert_clean(name: &str, tally: Tally) { + let mut summary = format!( + "{name}: {} compared, {} exact, {} documented unknown\n", + tally.compared, tally.exact, tally.documented_unknown + ); + for (category, failures) in &tally.failures { + summary.push_str(&format!(" {category}: {}\n", failures.len())); + } + eprintln!("{summary}"); + if let Ok(path) = std::env::var("ENGINE_TYPE_TRUTH_REPORT") { + let details: String = tally + .failures + .iter() + .flat_map(|(category, failures)| { + failures + .iter() + .map(move |failure| format!("[{category}] {failure}\n")) + }) + .collect(); + std::fs::write(format!("{path}.{name}.txt"), details).unwrap(); + } + let total: usize = tally.failures.values().map(Vec::len).sum(); + assert_eq!(total, 0, "{summary}"); +} + +#[test] +fn duckdb_engine_type_matrix_replays_without_mismatches() { + let tally = replay( + include_str!("fixtures/engine_types/duckdb.json"), + DialectType::DuckDB, + ); + assert_clean("duckdb", tally); +} + +#[test] +fn postgres_engine_type_matrix_replays_without_mismatches() { + let tally = replay( + include_str!("fixtures/engine_types/postgres.json"), + DialectType::PostgreSQL, + ); + assert_clean("postgres", tally); +} diff --git a/crates/polyglot-sql/tests/fixtures/engine_types/duckdb.json b/crates/polyglot-sql/tests/fixtures/engine_types/duckdb.json new file mode 100644 index 00000000..6f5cc914 --- /dev/null +++ b/crates/polyglot-sql/tests/fixtures/engine_types/duckdb.json @@ -0,0 +1,2877 @@ +{ + "engine": "duckdb", + "engine_version": "1.5.2", + "method": "DESCRIBE of SELECT over one-row synthetic table t, cross-checked with typeof()", + "schema": { + "tables": [ + { + "name": "t", + "columns": [ + { + "name": "c_tinyint", + "type": "TINYINT" + }, + { + "name": "c_smallint", + "type": "SMALLINT" + }, + { + "name": "c_integer", + "type": "INTEGER" + }, + { + "name": "c_bigint", + "type": "BIGINT" + }, + { + "name": "c_hugeint", + "type": "HUGEINT" + }, + { + "name": "c_utinyint", + "type": "UTINYINT" + }, + { + "name": "c_usmallint", + "type": "USMALLINT" + }, + { + "name": "c_uinteger", + "type": "UINTEGER" + }, + { + "name": "c_ubigint", + "type": "UBIGINT" + }, + { + "name": "c_uhugeint", + "type": "UHUGEINT" + }, + { + "name": "c_dec4_1", + "type": "DECIMAL(4,1)" + }, + { + "name": "c_dec9_2", + "type": "DECIMAL(9,2)" + }, + { + "name": "c_dec18_4", + "type": "DECIMAL(18,4)" + }, + { + "name": "c_dec38_10", + "type": "DECIMAL(38,10)" + }, + { + "name": "c_real", + "type": "REAL" + }, + { + "name": "c_double", + "type": "DOUBLE" + }, + { + "name": "c_varchar", + "type": "VARCHAR" + }, + { + "name": "c_boolean", + "type": "BOOLEAN" + }, + { + "name": "c_date", + "type": "DATE" + }, + { + "name": "c_timestamp", + "type": "TIMESTAMP" + }, + { + "name": "c_timestamptz", + "type": "TIMESTAMPTZ" + }, + { + "name": "c_time", + "type": "TIME" + }, + { + "name": "c_interval", + "type": "INTERVAL" + } + ] + } + ] + }, + "cases": [ + {"id": "arithmetic: c_tinyint + c_tinyint", "category": "arithmetic", "sql": "SELECT c_tinyint + c_tinyint AS v FROM t", "type": "TINYINT"}, + {"id": "arithmetic: c_tinyint + c_smallint", "category": "arithmetic", "sql": "SELECT c_tinyint + c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_tinyint + c_integer", "category": "arithmetic", "sql": "SELECT c_tinyint + c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_tinyint + c_bigint", "category": "arithmetic", "sql": "SELECT c_tinyint + c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint + c_hugeint", "category": "arithmetic", "sql": "SELECT c_tinyint + c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_tinyint + c_utinyint", "category": "arithmetic", "sql": "SELECT c_tinyint + c_utinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint + c_usmallint", "category": "arithmetic", "sql": "SELECT c_tinyint + c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint + c_uinteger", "category": "arithmetic", "sql": "SELECT c_tinyint + c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint + c_ubigint", "category": "arithmetic", "sql": "SELECT c_tinyint + c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_tinyint + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_tinyint + c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_tinyint + c_dec4_1 AS v FROM t", "type": "DECIMAL(5,1)"}, + {"id": "arithmetic: c_tinyint + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_tinyint + c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_tinyint + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_tinyint + c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_tinyint + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_tinyint + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_tinyint + c_real", "category": "arithmetic", "sql": "SELECT c_tinyint + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_tinyint + c_double", "category": "arithmetic", "sql": "SELECT c_tinyint + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint + c_tinyint", "category": "arithmetic", "sql": "SELECT c_smallint + c_tinyint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint + c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint + c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint + c_integer", "category": "arithmetic", "sql": "SELECT c_smallint + c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_smallint + c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint + c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint + c_hugeint", "category": "arithmetic", "sql": "SELECT c_smallint + c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_smallint + c_utinyint", "category": "arithmetic", "sql": "SELECT c_smallint + c_utinyint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint + c_usmallint", "category": "arithmetic", "sql": "SELECT c_smallint + c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint + c_uinteger", "category": "arithmetic", "sql": "SELECT c_smallint + c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint + c_ubigint", "category": "arithmetic", "sql": "SELECT c_smallint + c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_smallint + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_smallint + c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_smallint + c_dec4_1 AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_smallint + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_smallint + c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_smallint + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_smallint + c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_smallint + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_smallint + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_smallint + c_real", "category": "arithmetic", "sql": "SELECT c_smallint + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_smallint + c_double", "category": "arithmetic", "sql": "SELECT c_smallint + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer + c_tinyint", "category": "arithmetic", "sql": "SELECT c_integer + c_tinyint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer + c_smallint", "category": "arithmetic", "sql": "SELECT c_integer + c_smallint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer + c_integer", "category": "arithmetic", "sql": "SELECT c_integer + c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer + c_bigint", "category": "arithmetic", "sql": "SELECT c_integer + c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_integer + c_hugeint", "category": "arithmetic", "sql": "SELECT c_integer + c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_integer + c_utinyint", "category": "arithmetic", "sql": "SELECT c_integer + c_utinyint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer + c_usmallint", "category": "arithmetic", "sql": "SELECT c_integer + c_usmallint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer + c_uinteger", "category": "arithmetic", "sql": "SELECT c_integer + c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_integer + c_ubigint", "category": "arithmetic", "sql": "SELECT c_integer + c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_integer + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_integer + c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_integer + c_dec4_1 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic: c_integer + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_integer + c_dec9_2 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic: c_integer + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_integer + c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_integer + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_integer + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_integer + c_real", "category": "arithmetic", "sql": "SELECT c_integer + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_integer + c_double", "category": "arithmetic", "sql": "SELECT c_integer + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint + c_tinyint", "category": "arithmetic", "sql": "SELECT c_bigint + c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint + c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint + c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint + c_integer", "category": "arithmetic", "sql": "SELECT c_bigint + c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint + c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint + c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint + c_hugeint", "category": "arithmetic", "sql": "SELECT c_bigint + c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_bigint + c_utinyint", "category": "arithmetic", "sql": "SELECT c_bigint + c_utinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint + c_usmallint", "category": "arithmetic", "sql": "SELECT c_bigint + c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint + c_uinteger", "category": "arithmetic", "sql": "SELECT c_bigint + c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint + c_ubigint", "category": "arithmetic", "sql": "SELECT c_bigint + c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_bigint + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_bigint + c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_bigint + c_dec4_1 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic: c_bigint + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_bigint + c_dec9_2 AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic: c_bigint + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_bigint + c_dec18_4 AS v FROM t", "type": "DECIMAL(24,4)"}, + {"id": "arithmetic: c_bigint + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_bigint + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_bigint + c_real", "category": "arithmetic", "sql": "SELECT c_bigint + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_bigint + c_double", "category": "arithmetic", "sql": "SELECT c_bigint + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint + c_tinyint", "category": "arithmetic", "sql": "SELECT c_hugeint + c_tinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint + c_smallint", "category": "arithmetic", "sql": "SELECT c_hugeint + c_smallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint + c_integer", "category": "arithmetic", "sql": "SELECT c_hugeint + c_integer AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint + c_bigint", "category": "arithmetic", "sql": "SELECT c_hugeint + c_bigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint + c_hugeint", "category": "arithmetic", "sql": "SELECT c_hugeint + c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint + c_utinyint", "category": "arithmetic", "sql": "SELECT c_hugeint + c_utinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint + c_usmallint", "category": "arithmetic", "sql": "SELECT c_hugeint + c_usmallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint + c_uinteger", "category": "arithmetic", "sql": "SELECT c_hugeint + c_uinteger AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint + c_ubigint", "category": "arithmetic", "sql": "SELECT c_hugeint + c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_hugeint + c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_hugeint + c_dec4_1 AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_hugeint + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_hugeint + c_dec9_2 AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_hugeint + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_hugeint + c_dec18_4 AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_hugeint + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_hugeint + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_hugeint + c_real", "category": "arithmetic", "sql": "SELECT c_hugeint + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_hugeint + c_double", "category": "arithmetic", "sql": "SELECT c_hugeint + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint + c_tinyint", "category": "arithmetic", "sql": "SELECT c_utinyint + c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_utinyint + c_smallint", "category": "arithmetic", "sql": "SELECT c_utinyint + c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_utinyint + c_integer", "category": "arithmetic", "sql": "SELECT c_utinyint + c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_utinyint + c_bigint", "category": "arithmetic", "sql": "SELECT c_utinyint + c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_utinyint + c_hugeint", "category": "arithmetic", "sql": "SELECT c_utinyint + c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_utinyint + c_utinyint", "category": "arithmetic", "sql": "SELECT c_utinyint + c_utinyint AS v FROM t", "type": "UTINYINT"}, + {"id": "arithmetic: c_utinyint + c_usmallint", "category": "arithmetic", "sql": "SELECT c_utinyint + c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_utinyint + c_uinteger", "category": "arithmetic", "sql": "SELECT c_utinyint + c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_utinyint + c_ubigint", "category": "arithmetic", "sql": "SELECT c_utinyint + c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_utinyint + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_utinyint + c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_utinyint + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_utinyint + c_dec4_1 AS v FROM t", "type": "DECIMAL(5,1)"}, + {"id": "arithmetic: c_utinyint + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_utinyint + c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_utinyint + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_utinyint + c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_utinyint + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_utinyint + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_utinyint + c_real", "category": "arithmetic", "sql": "SELECT c_utinyint + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_utinyint + c_double", "category": "arithmetic", "sql": "SELECT c_utinyint + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint + c_tinyint", "category": "arithmetic", "sql": "SELECT c_usmallint + c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint + c_smallint", "category": "arithmetic", "sql": "SELECT c_usmallint + c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint + c_integer", "category": "arithmetic", "sql": "SELECT c_usmallint + c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_usmallint + c_bigint", "category": "arithmetic", "sql": "SELECT c_usmallint + c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint + c_hugeint", "category": "arithmetic", "sql": "SELECT c_usmallint + c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_usmallint + c_utinyint", "category": "arithmetic", "sql": "SELECT c_usmallint + c_utinyint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_usmallint + c_usmallint", "category": "arithmetic", "sql": "SELECT c_usmallint + c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_usmallint + c_uinteger", "category": "arithmetic", "sql": "SELECT c_usmallint + c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_usmallint + c_ubigint", "category": "arithmetic", "sql": "SELECT c_usmallint + c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_usmallint + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_usmallint + c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_usmallint + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_usmallint + c_dec4_1 AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_usmallint + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_usmallint + c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_usmallint + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_usmallint + c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_usmallint + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_usmallint + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_usmallint + c_real", "category": "arithmetic", "sql": "SELECT c_usmallint + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_usmallint + c_double", "category": "arithmetic", "sql": "SELECT c_usmallint + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger + c_tinyint", "category": "arithmetic", "sql": "SELECT c_uinteger + c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger + c_smallint", "category": "arithmetic", "sql": "SELECT c_uinteger + c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger + c_integer", "category": "arithmetic", "sql": "SELECT c_uinteger + c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger + c_bigint", "category": "arithmetic", "sql": "SELECT c_uinteger + c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger + c_hugeint", "category": "arithmetic", "sql": "SELECT c_uinteger + c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_uinteger + c_utinyint", "category": "arithmetic", "sql": "SELECT c_uinteger + c_utinyint AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger + c_usmallint", "category": "arithmetic", "sql": "SELECT c_uinteger + c_usmallint AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger + c_uinteger", "category": "arithmetic", "sql": "SELECT c_uinteger + c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger + c_ubigint", "category": "arithmetic", "sql": "SELECT c_uinteger + c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_uinteger + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uinteger + c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uinteger + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uinteger + c_dec4_1 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic: c_uinteger + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uinteger + c_dec9_2 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic: c_uinteger + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uinteger + c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_uinteger + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uinteger + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_uinteger + c_real", "category": "arithmetic", "sql": "SELECT c_uinteger + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uinteger + c_double", "category": "arithmetic", "sql": "SELECT c_uinteger + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint + c_tinyint", "category": "arithmetic", "sql": "SELECT c_ubigint + c_tinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint + c_smallint", "category": "arithmetic", "sql": "SELECT c_ubigint + c_smallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint + c_integer", "category": "arithmetic", "sql": "SELECT c_ubigint + c_integer AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint + c_bigint", "category": "arithmetic", "sql": "SELECT c_ubigint + c_bigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint + c_hugeint", "category": "arithmetic", "sql": "SELECT c_ubigint + c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint + c_utinyint", "category": "arithmetic", "sql": "SELECT c_ubigint + c_utinyint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint + c_usmallint", "category": "arithmetic", "sql": "SELECT c_ubigint + c_usmallint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint + c_uinteger", "category": "arithmetic", "sql": "SELECT c_ubigint + c_uinteger AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint + c_ubigint", "category": "arithmetic", "sql": "SELECT c_ubigint + c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_ubigint + c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_ubigint + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_ubigint + c_dec4_1 AS v FROM t", "type": "DECIMAL(22,1)"}, + {"id": "arithmetic: c_ubigint + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_ubigint + c_dec9_2 AS v FROM t", "type": "DECIMAL(23,2)"}, + {"id": "arithmetic: c_ubigint + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_ubigint + c_dec18_4 AS v FROM t", "type": "DECIMAL(25,4)"}, + {"id": "arithmetic: c_ubigint + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_ubigint + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_ubigint + c_real", "category": "arithmetic", "sql": "SELECT c_ubigint + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_ubigint + c_double", "category": "arithmetic", "sql": "SELECT c_ubigint + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint + c_tinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint + c_smallint", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint + c_integer", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint + c_bigint", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint + c_hugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint + c_utinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_utinyint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint + c_usmallint", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_usmallint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint + c_uinteger", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_uinteger AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint + c_ubigint", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_ubigint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_dec4_1 AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_uhugeint + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_dec9_2 AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_uhugeint + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_dec18_4 AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_uhugeint + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_uhugeint + c_real", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uhugeint + c_double", "category": "arithmetic", "sql": "SELECT c_uhugeint + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 + c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_tinyint AS v FROM t", "type": "DECIMAL(5,1)"}, + {"id": "arithmetic: c_dec4_1 + c_smallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_smallint AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_dec4_1 + c_integer", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_integer AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic: c_dec4_1 + c_bigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_bigint AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic: c_dec4_1 + c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_hugeint AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_dec4_1 + c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_utinyint AS v FROM t", "type": "DECIMAL(5,1)"}, + {"id": "arithmetic: c_dec4_1 + c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_usmallint AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_dec4_1 + c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_uinteger AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic: c_dec4_1 + c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_ubigint AS v FROM t", "type": "DECIMAL(22,1)"}, + {"id": "arithmetic: c_dec4_1 + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_uhugeint AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_dec4_1 + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_dec4_1 AS v FROM t", "type": "DECIMAL(5,1)"}, + {"id": "arithmetic: c_dec4_1 + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec4_1 + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec4_1 + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec4_1 + c_real", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec4_1 + c_double", "category": "arithmetic", "sql": "SELECT c_dec4_1 + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 + c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_tinyint AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 + c_smallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_smallint AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 + c_integer", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_integer AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic: c_dec9_2 + c_bigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_bigint AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic: c_dec9_2 + c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_hugeint AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_dec9_2 + c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_utinyint AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 + c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_usmallint AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 + c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_uinteger AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic: c_dec9_2 + c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_ubigint AS v FROM t", "type": "DECIMAL(23,2)"}, + {"id": "arithmetic: c_dec9_2 + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_uhugeint AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_dec9_2 + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_dec4_1 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec9_2 + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec9_2 + c_real", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec9_2 + c_double", "category": "arithmetic", "sql": "SELECT c_dec9_2 + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 + c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_tinyint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 + c_smallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_smallint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 + c_integer", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_integer AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 + c_bigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_bigint AS v FROM t", "type": "DECIMAL(24,4)"}, + {"id": "arithmetic: c_dec18_4 + c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_hugeint AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_dec18_4 + c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_utinyint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 + c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_usmallint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 + c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_uinteger AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 + c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_ubigint AS v FROM t", "type": "DECIMAL(25,4)"}, + {"id": "arithmetic: c_dec18_4 + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_uhugeint AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_dec18_4 + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_dec4_1 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_dec9_2 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec18_4 + c_real", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec18_4 + c_double", "category": "arithmetic", "sql": "SELECT c_dec18_4 + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 + c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_tinyint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_smallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_smallint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_integer", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_integer AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_bigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_bigint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_hugeint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_utinyint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_usmallint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_uinteger AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_ubigint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_uhugeint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_dec4_1 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_dec9_2 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_dec18_4 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 + c_real", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec38_10 + c_double", "category": "arithmetic", "sql": "SELECT c_dec38_10 + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_real + c_tinyint", "category": "arithmetic", "sql": "SELECT c_real + c_tinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_smallint", "category": "arithmetic", "sql": "SELECT c_real + c_smallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_integer", "category": "arithmetic", "sql": "SELECT c_real + c_integer AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_bigint", "category": "arithmetic", "sql": "SELECT c_real + c_bigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_hugeint", "category": "arithmetic", "sql": "SELECT c_real + c_hugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_utinyint", "category": "arithmetic", "sql": "SELECT c_real + c_utinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_usmallint", "category": "arithmetic", "sql": "SELECT c_real + c_usmallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_uinteger", "category": "arithmetic", "sql": "SELECT c_real + c_uinteger AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_ubigint", "category": "arithmetic", "sql": "SELECT c_real + c_ubigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_real + c_uhugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_real + c_dec4_1 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_real + c_dec9_2 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_real + c_dec18_4 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_real + c_dec38_10 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_real", "category": "arithmetic", "sql": "SELECT c_real + c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real + c_double", "category": "arithmetic", "sql": "SELECT c_real + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_tinyint", "category": "arithmetic", "sql": "SELECT c_double + c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_smallint", "category": "arithmetic", "sql": "SELECT c_double + c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_integer", "category": "arithmetic", "sql": "SELECT c_double + c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_bigint", "category": "arithmetic", "sql": "SELECT c_double + c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_hugeint", "category": "arithmetic", "sql": "SELECT c_double + c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_utinyint", "category": "arithmetic", "sql": "SELECT c_double + c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_usmallint", "category": "arithmetic", "sql": "SELECT c_double + c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_uinteger", "category": "arithmetic", "sql": "SELECT c_double + c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_ubigint", "category": "arithmetic", "sql": "SELECT c_double + c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_uhugeint", "category": "arithmetic", "sql": "SELECT c_double + c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_dec4_1", "category": "arithmetic", "sql": "SELECT c_double + c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_dec9_2", "category": "arithmetic", "sql": "SELECT c_double + c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_dec18_4", "category": "arithmetic", "sql": "SELECT c_double + c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_dec38_10", "category": "arithmetic", "sql": "SELECT c_double + c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_real", "category": "arithmetic", "sql": "SELECT c_double + c_real AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double + c_double", "category": "arithmetic", "sql": "SELECT c_double + c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint - c_tinyint", "category": "arithmetic", "sql": "SELECT c_tinyint - c_tinyint AS v FROM t", "type": "TINYINT"}, + {"id": "arithmetic: c_tinyint - c_smallint", "category": "arithmetic", "sql": "SELECT c_tinyint - c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_tinyint - c_integer", "category": "arithmetic", "sql": "SELECT c_tinyint - c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_tinyint - c_bigint", "category": "arithmetic", "sql": "SELECT c_tinyint - c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint - c_hugeint", "category": "arithmetic", "sql": "SELECT c_tinyint - c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_tinyint - c_utinyint", "category": "arithmetic", "sql": "SELECT c_tinyint - c_utinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint - c_usmallint", "category": "arithmetic", "sql": "SELECT c_tinyint - c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint - c_uinteger", "category": "arithmetic", "sql": "SELECT c_tinyint - c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint - c_ubigint", "category": "arithmetic", "sql": "SELECT c_tinyint - c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_tinyint - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_tinyint - c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_tinyint - c_dec4_1 AS v FROM t", "type": "DECIMAL(5,1)"}, + {"id": "arithmetic: c_tinyint - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_tinyint - c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_tinyint - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_tinyint - c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_tinyint - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_tinyint - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_tinyint - c_real", "category": "arithmetic", "sql": "SELECT c_tinyint - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_tinyint - c_double", "category": "arithmetic", "sql": "SELECT c_tinyint - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint - c_tinyint", "category": "arithmetic", "sql": "SELECT c_smallint - c_tinyint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint - c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint - c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint - c_integer", "category": "arithmetic", "sql": "SELECT c_smallint - c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_smallint - c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint - c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint - c_hugeint", "category": "arithmetic", "sql": "SELECT c_smallint - c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_smallint - c_utinyint", "category": "arithmetic", "sql": "SELECT c_smallint - c_utinyint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint - c_usmallint", "category": "arithmetic", "sql": "SELECT c_smallint - c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint - c_uinteger", "category": "arithmetic", "sql": "SELECT c_smallint - c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint - c_ubigint", "category": "arithmetic", "sql": "SELECT c_smallint - c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_smallint - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_smallint - c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_smallint - c_dec4_1 AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_smallint - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_smallint - c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_smallint - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_smallint - c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_smallint - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_smallint - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_smallint - c_real", "category": "arithmetic", "sql": "SELECT c_smallint - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_smallint - c_double", "category": "arithmetic", "sql": "SELECT c_smallint - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer - c_tinyint", "category": "arithmetic", "sql": "SELECT c_integer - c_tinyint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer - c_smallint", "category": "arithmetic", "sql": "SELECT c_integer - c_smallint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer - c_integer", "category": "arithmetic", "sql": "SELECT c_integer - c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer - c_bigint", "category": "arithmetic", "sql": "SELECT c_integer - c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_integer - c_hugeint", "category": "arithmetic", "sql": "SELECT c_integer - c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_integer - c_utinyint", "category": "arithmetic", "sql": "SELECT c_integer - c_utinyint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer - c_usmallint", "category": "arithmetic", "sql": "SELECT c_integer - c_usmallint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer - c_uinteger", "category": "arithmetic", "sql": "SELECT c_integer - c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_integer - c_ubigint", "category": "arithmetic", "sql": "SELECT c_integer - c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_integer - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_integer - c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_integer - c_dec4_1 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic: c_integer - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_integer - c_dec9_2 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic: c_integer - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_integer - c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_integer - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_integer - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_integer - c_real", "category": "arithmetic", "sql": "SELECT c_integer - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_integer - c_double", "category": "arithmetic", "sql": "SELECT c_integer - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint - c_tinyint", "category": "arithmetic", "sql": "SELECT c_bigint - c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint - c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint - c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint - c_integer", "category": "arithmetic", "sql": "SELECT c_bigint - c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint - c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint - c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint - c_hugeint", "category": "arithmetic", "sql": "SELECT c_bigint - c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_bigint - c_utinyint", "category": "arithmetic", "sql": "SELECT c_bigint - c_utinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint - c_usmallint", "category": "arithmetic", "sql": "SELECT c_bigint - c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint - c_uinteger", "category": "arithmetic", "sql": "SELECT c_bigint - c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint - c_ubigint", "category": "arithmetic", "sql": "SELECT c_bigint - c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_bigint - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_bigint - c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_bigint - c_dec4_1 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic: c_bigint - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_bigint - c_dec9_2 AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic: c_bigint - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_bigint - c_dec18_4 AS v FROM t", "type": "DECIMAL(24,4)"}, + {"id": "arithmetic: c_bigint - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_bigint - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_bigint - c_real", "category": "arithmetic", "sql": "SELECT c_bigint - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_bigint - c_double", "category": "arithmetic", "sql": "SELECT c_bigint - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint - c_tinyint", "category": "arithmetic", "sql": "SELECT c_hugeint - c_tinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint - c_smallint", "category": "arithmetic", "sql": "SELECT c_hugeint - c_smallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint - c_integer", "category": "arithmetic", "sql": "SELECT c_hugeint - c_integer AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint - c_bigint", "category": "arithmetic", "sql": "SELECT c_hugeint - c_bigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint - c_hugeint", "category": "arithmetic", "sql": "SELECT c_hugeint - c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint - c_utinyint", "category": "arithmetic", "sql": "SELECT c_hugeint - c_utinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint - c_usmallint", "category": "arithmetic", "sql": "SELECT c_hugeint - c_usmallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint - c_uinteger", "category": "arithmetic", "sql": "SELECT c_hugeint - c_uinteger AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint - c_ubigint", "category": "arithmetic", "sql": "SELECT c_hugeint - c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_hugeint - c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_hugeint - c_dec4_1 AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_hugeint - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_hugeint - c_dec9_2 AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_hugeint - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_hugeint - c_dec18_4 AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_hugeint - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_hugeint - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_hugeint - c_real", "category": "arithmetic", "sql": "SELECT c_hugeint - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_hugeint - c_double", "category": "arithmetic", "sql": "SELECT c_hugeint - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint - c_tinyint", "category": "arithmetic", "sql": "SELECT c_utinyint - c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_utinyint - c_smallint", "category": "arithmetic", "sql": "SELECT c_utinyint - c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_utinyint - c_integer", "category": "arithmetic", "sql": "SELECT c_utinyint - c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_utinyint - c_bigint", "category": "arithmetic", "sql": "SELECT c_utinyint - c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_utinyint - c_hugeint", "category": "arithmetic", "sql": "SELECT c_utinyint - c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_utinyint - c_utinyint", "category": "arithmetic", "sql": "SELECT c_utinyint - c_utinyint AS v FROM t", "type": "UTINYINT"}, + {"id": "arithmetic: c_utinyint - c_usmallint", "category": "arithmetic", "sql": "SELECT c_utinyint - c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_utinyint - c_uinteger", "category": "arithmetic", "sql": "SELECT c_utinyint - c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_utinyint - c_ubigint", "category": "arithmetic", "sql": "SELECT c_utinyint - c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_utinyint - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_utinyint - c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_utinyint - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_utinyint - c_dec4_1 AS v FROM t", "type": "DECIMAL(5,1)"}, + {"id": "arithmetic: c_utinyint - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_utinyint - c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_utinyint - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_utinyint - c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_utinyint - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_utinyint - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_utinyint - c_real", "category": "arithmetic", "sql": "SELECT c_utinyint - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_utinyint - c_double", "category": "arithmetic", "sql": "SELECT c_utinyint - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint - c_tinyint", "category": "arithmetic", "sql": "SELECT c_usmallint - c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint - c_smallint", "category": "arithmetic", "sql": "SELECT c_usmallint - c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint - c_integer", "category": "arithmetic", "sql": "SELECT c_usmallint - c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_usmallint - c_bigint", "category": "arithmetic", "sql": "SELECT c_usmallint - c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint - c_hugeint", "category": "arithmetic", "sql": "SELECT c_usmallint - c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_usmallint - c_utinyint", "category": "arithmetic", "sql": "SELECT c_usmallint - c_utinyint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_usmallint - c_usmallint", "category": "arithmetic", "sql": "SELECT c_usmallint - c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_usmallint - c_uinteger", "category": "arithmetic", "sql": "SELECT c_usmallint - c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_usmallint - c_ubigint", "category": "arithmetic", "sql": "SELECT c_usmallint - c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_usmallint - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_usmallint - c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_usmallint - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_usmallint - c_dec4_1 AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_usmallint - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_usmallint - c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_usmallint - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_usmallint - c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_usmallint - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_usmallint - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_usmallint - c_real", "category": "arithmetic", "sql": "SELECT c_usmallint - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_usmallint - c_double", "category": "arithmetic", "sql": "SELECT c_usmallint - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger - c_tinyint", "category": "arithmetic", "sql": "SELECT c_uinteger - c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger - c_smallint", "category": "arithmetic", "sql": "SELECT c_uinteger - c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger - c_integer", "category": "arithmetic", "sql": "SELECT c_uinteger - c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger - c_bigint", "category": "arithmetic", "sql": "SELECT c_uinteger - c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger - c_hugeint", "category": "arithmetic", "sql": "SELECT c_uinteger - c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_uinteger - c_utinyint", "category": "arithmetic", "sql": "SELECT c_uinteger - c_utinyint AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger - c_usmallint", "category": "arithmetic", "sql": "SELECT c_uinteger - c_usmallint AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger - c_uinteger", "category": "arithmetic", "sql": "SELECT c_uinteger - c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger - c_ubigint", "category": "arithmetic", "sql": "SELECT c_uinteger - c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_uinteger - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uinteger - c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uinteger - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uinteger - c_dec4_1 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic: c_uinteger - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uinteger - c_dec9_2 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic: c_uinteger - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uinteger - c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_uinteger - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uinteger - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_uinteger - c_real", "category": "arithmetic", "sql": "SELECT c_uinteger - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uinteger - c_double", "category": "arithmetic", "sql": "SELECT c_uinteger - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint - c_tinyint", "category": "arithmetic", "sql": "SELECT c_ubigint - c_tinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint - c_smallint", "category": "arithmetic", "sql": "SELECT c_ubigint - c_smallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint - c_integer", "category": "arithmetic", "sql": "SELECT c_ubigint - c_integer AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint - c_bigint", "category": "arithmetic", "sql": "SELECT c_ubigint - c_bigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint - c_hugeint", "category": "arithmetic", "sql": "SELECT c_ubigint - c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint - c_utinyint", "category": "arithmetic", "sql": "SELECT c_ubigint - c_utinyint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint - c_usmallint", "category": "arithmetic", "sql": "SELECT c_ubigint - c_usmallint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint - c_uinteger", "category": "arithmetic", "sql": "SELECT c_ubigint - c_uinteger AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint - c_ubigint", "category": "arithmetic", "sql": "SELECT c_ubigint - c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_ubigint - c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_ubigint - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_ubigint - c_dec4_1 AS v FROM t", "type": "DECIMAL(22,1)"}, + {"id": "arithmetic: c_ubigint - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_ubigint - c_dec9_2 AS v FROM t", "type": "DECIMAL(23,2)"}, + {"id": "arithmetic: c_ubigint - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_ubigint - c_dec18_4 AS v FROM t", "type": "DECIMAL(25,4)"}, + {"id": "arithmetic: c_ubigint - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_ubigint - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_ubigint - c_real", "category": "arithmetic", "sql": "SELECT c_ubigint - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_ubigint - c_double", "category": "arithmetic", "sql": "SELECT c_ubigint - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint - c_tinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint - c_smallint", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint - c_integer", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint - c_bigint", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint - c_hugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint - c_utinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_utinyint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint - c_usmallint", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_usmallint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint - c_uinteger", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_uinteger AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint - c_ubigint", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_ubigint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_dec4_1 AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_uhugeint - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_dec9_2 AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_uhugeint - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_dec18_4 AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_uhugeint - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_uhugeint - c_real", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uhugeint - c_double", "category": "arithmetic", "sql": "SELECT c_uhugeint - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 - c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_tinyint AS v FROM t", "type": "DECIMAL(5,1)"}, + {"id": "arithmetic: c_dec4_1 - c_smallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_smallint AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_dec4_1 - c_integer", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_integer AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic: c_dec4_1 - c_bigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_bigint AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic: c_dec4_1 - c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_hugeint AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_dec4_1 - c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_utinyint AS v FROM t", "type": "DECIMAL(5,1)"}, + {"id": "arithmetic: c_dec4_1 - c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_usmallint AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_dec4_1 - c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_uinteger AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic: c_dec4_1 - c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_ubigint AS v FROM t", "type": "DECIMAL(22,1)"}, + {"id": "arithmetic: c_dec4_1 - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_uhugeint AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_dec4_1 - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_dec4_1 AS v FROM t", "type": "DECIMAL(5,1)"}, + {"id": "arithmetic: c_dec4_1 - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec4_1 - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec4_1 - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec4_1 - c_real", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec4_1 - c_double", "category": "arithmetic", "sql": "SELECT c_dec4_1 - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 - c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_tinyint AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 - c_smallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_smallint AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 - c_integer", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_integer AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic: c_dec9_2 - c_bigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_bigint AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic: c_dec9_2 - c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_hugeint AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_dec9_2 - c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_utinyint AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 - c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_usmallint AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 - c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_uinteger AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic: c_dec9_2 - c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_ubigint AS v FROM t", "type": "DECIMAL(23,2)"}, + {"id": "arithmetic: c_dec9_2 - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_uhugeint AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_dec9_2 - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_dec4_1 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_dec9_2 AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "arithmetic: c_dec9_2 - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec9_2 - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec9_2 - c_real", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec9_2 - c_double", "category": "arithmetic", "sql": "SELECT c_dec9_2 - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 - c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_tinyint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 - c_smallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_smallint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 - c_integer", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_integer AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 - c_bigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_bigint AS v FROM t", "type": "DECIMAL(24,4)"}, + {"id": "arithmetic: c_dec18_4 - c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_hugeint AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_dec18_4 - c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_utinyint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 - c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_usmallint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 - c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_uinteger AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 - c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_ubigint AS v FROM t", "type": "DECIMAL(25,4)"}, + {"id": "arithmetic: c_dec18_4 - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_uhugeint AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_dec18_4 - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_dec4_1 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_dec9_2 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec18_4 - c_real", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec18_4 - c_double", "category": "arithmetic", "sql": "SELECT c_dec18_4 - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 - c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_tinyint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_smallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_smallint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_integer", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_integer AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_bigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_bigint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_hugeint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_utinyint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_usmallint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_uinteger AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_ubigint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_uhugeint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_dec4_1 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_dec9_2 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_dec18_4 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 - c_real", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec38_10 - c_double", "category": "arithmetic", "sql": "SELECT c_dec38_10 - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_real - c_tinyint", "category": "arithmetic", "sql": "SELECT c_real - c_tinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_smallint", "category": "arithmetic", "sql": "SELECT c_real - c_smallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_integer", "category": "arithmetic", "sql": "SELECT c_real - c_integer AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_bigint", "category": "arithmetic", "sql": "SELECT c_real - c_bigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_hugeint", "category": "arithmetic", "sql": "SELECT c_real - c_hugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_utinyint", "category": "arithmetic", "sql": "SELECT c_real - c_utinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_usmallint", "category": "arithmetic", "sql": "SELECT c_real - c_usmallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_uinteger", "category": "arithmetic", "sql": "SELECT c_real - c_uinteger AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_ubigint", "category": "arithmetic", "sql": "SELECT c_real - c_ubigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_real - c_uhugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_real - c_dec4_1 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_real - c_dec9_2 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_real - c_dec18_4 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_real - c_dec38_10 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_real", "category": "arithmetic", "sql": "SELECT c_real - c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real - c_double", "category": "arithmetic", "sql": "SELECT c_real - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_tinyint", "category": "arithmetic", "sql": "SELECT c_double - c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_smallint", "category": "arithmetic", "sql": "SELECT c_double - c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_integer", "category": "arithmetic", "sql": "SELECT c_double - c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_bigint", "category": "arithmetic", "sql": "SELECT c_double - c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_hugeint", "category": "arithmetic", "sql": "SELECT c_double - c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_utinyint", "category": "arithmetic", "sql": "SELECT c_double - c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_usmallint", "category": "arithmetic", "sql": "SELECT c_double - c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_uinteger", "category": "arithmetic", "sql": "SELECT c_double - c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_ubigint", "category": "arithmetic", "sql": "SELECT c_double - c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_uhugeint", "category": "arithmetic", "sql": "SELECT c_double - c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_dec4_1", "category": "arithmetic", "sql": "SELECT c_double - c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_dec9_2", "category": "arithmetic", "sql": "SELECT c_double - c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_dec18_4", "category": "arithmetic", "sql": "SELECT c_double - c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_dec38_10", "category": "arithmetic", "sql": "SELECT c_double - c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_real", "category": "arithmetic", "sql": "SELECT c_double - c_real AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double - c_double", "category": "arithmetic", "sql": "SELECT c_double - c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint * c_tinyint", "category": "arithmetic", "sql": "SELECT c_tinyint * c_tinyint AS v FROM t", "type": "TINYINT"}, + {"id": "arithmetic: c_tinyint * c_smallint", "category": "arithmetic", "sql": "SELECT c_tinyint * c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_tinyint * c_integer", "category": "arithmetic", "sql": "SELECT c_tinyint * c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_tinyint * c_bigint", "category": "arithmetic", "sql": "SELECT c_tinyint * c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint * c_hugeint", "category": "arithmetic", "sql": "SELECT c_tinyint * c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_tinyint * c_utinyint", "category": "arithmetic", "sql": "SELECT c_tinyint * c_utinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint * c_usmallint", "category": "arithmetic", "sql": "SELECT c_tinyint * c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint * c_uinteger", "category": "arithmetic", "sql": "SELECT c_tinyint * c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint * c_ubigint", "category": "arithmetic", "sql": "SELECT c_tinyint * c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_tinyint * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_tinyint * c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_tinyint * c_dec4_1 AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_tinyint * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_tinyint * c_dec9_2 AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic: c_tinyint * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_tinyint * c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_tinyint * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_tinyint * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_tinyint * c_real", "category": "arithmetic", "sql": "SELECT c_tinyint * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_tinyint * c_double", "category": "arithmetic", "sql": "SELECT c_tinyint * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint * c_tinyint", "category": "arithmetic", "sql": "SELECT c_smallint * c_tinyint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint * c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint * c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint * c_integer", "category": "arithmetic", "sql": "SELECT c_smallint * c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_smallint * c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint * c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint * c_hugeint", "category": "arithmetic", "sql": "SELECT c_smallint * c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_smallint * c_utinyint", "category": "arithmetic", "sql": "SELECT c_smallint * c_utinyint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint * c_usmallint", "category": "arithmetic", "sql": "SELECT c_smallint * c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint * c_uinteger", "category": "arithmetic", "sql": "SELECT c_smallint * c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint * c_ubigint", "category": "arithmetic", "sql": "SELECT c_smallint * c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_smallint * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_smallint * c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_smallint * c_dec4_1 AS v FROM t", "type": "DECIMAL(9,1)"}, + {"id": "arithmetic: c_smallint * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_smallint * c_dec9_2 AS v FROM t", "type": "DECIMAL(14,2)"}, + {"id": "arithmetic: c_smallint * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_smallint * c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_smallint * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_smallint * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_smallint * c_real", "category": "arithmetic", "sql": "SELECT c_smallint * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_smallint * c_double", "category": "arithmetic", "sql": "SELECT c_smallint * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer * c_tinyint", "category": "arithmetic", "sql": "SELECT c_integer * c_tinyint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer * c_smallint", "category": "arithmetic", "sql": "SELECT c_integer * c_smallint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer * c_integer", "category": "arithmetic", "sql": "SELECT c_integer * c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer * c_bigint", "category": "arithmetic", "sql": "SELECT c_integer * c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_integer * c_hugeint", "category": "arithmetic", "sql": "SELECT c_integer * c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_integer * c_utinyint", "category": "arithmetic", "sql": "SELECT c_integer * c_utinyint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer * c_usmallint", "category": "arithmetic", "sql": "SELECT c_integer * c_usmallint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer * c_uinteger", "category": "arithmetic", "sql": "SELECT c_integer * c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_integer * c_ubigint", "category": "arithmetic", "sql": "SELECT c_integer * c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_integer * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_integer * c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_integer * c_dec4_1 AS v FROM t", "type": "DECIMAL(14,1)"}, + {"id": "arithmetic: c_integer * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_integer * c_dec9_2 AS v FROM t", "type": "DECIMAL(18,2)"}, + {"id": "arithmetic: c_integer * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_integer * c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_integer * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_integer * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_integer * c_real", "category": "arithmetic", "sql": "SELECT c_integer * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_integer * c_double", "category": "arithmetic", "sql": "SELECT c_integer * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint * c_tinyint", "category": "arithmetic", "sql": "SELECT c_bigint * c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint * c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint * c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint * c_integer", "category": "arithmetic", "sql": "SELECT c_bigint * c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint * c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint * c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint * c_hugeint", "category": "arithmetic", "sql": "SELECT c_bigint * c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_bigint * c_utinyint", "category": "arithmetic", "sql": "SELECT c_bigint * c_utinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint * c_usmallint", "category": "arithmetic", "sql": "SELECT c_bigint * c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint * c_uinteger", "category": "arithmetic", "sql": "SELECT c_bigint * c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint * c_ubigint", "category": "arithmetic", "sql": "SELECT c_bigint * c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_bigint * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_bigint * c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_bigint * c_dec4_1 AS v FROM t", "type": "DECIMAL(23,1)"}, + {"id": "arithmetic: c_bigint * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_bigint * c_dec9_2 AS v FROM t", "type": "DECIMAL(28,2)"}, + {"id": "arithmetic: c_bigint * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_bigint * c_dec18_4 AS v FROM t", "type": "DECIMAL(37,4)"}, + {"id": "arithmetic: c_bigint * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_bigint * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_bigint * c_real", "category": "arithmetic", "sql": "SELECT c_bigint * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_bigint * c_double", "category": "arithmetic", "sql": "SELECT c_bigint * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint * c_tinyint", "category": "arithmetic", "sql": "SELECT c_hugeint * c_tinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint * c_smallint", "category": "arithmetic", "sql": "SELECT c_hugeint * c_smallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint * c_integer", "category": "arithmetic", "sql": "SELECT c_hugeint * c_integer AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint * c_bigint", "category": "arithmetic", "sql": "SELECT c_hugeint * c_bigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint * c_hugeint", "category": "arithmetic", "sql": "SELECT c_hugeint * c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint * c_utinyint", "category": "arithmetic", "sql": "SELECT c_hugeint * c_utinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint * c_usmallint", "category": "arithmetic", "sql": "SELECT c_hugeint * c_usmallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint * c_uinteger", "category": "arithmetic", "sql": "SELECT c_hugeint * c_uinteger AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint * c_ubigint", "category": "arithmetic", "sql": "SELECT c_hugeint * c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_hugeint * c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_hugeint * c_dec4_1 AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_hugeint * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_hugeint * c_dec9_2 AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_hugeint * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_hugeint * c_dec18_4 AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_hugeint * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_hugeint * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_hugeint * c_real", "category": "arithmetic", "sql": "SELECT c_hugeint * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_hugeint * c_double", "category": "arithmetic", "sql": "SELECT c_hugeint * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint * c_tinyint", "category": "arithmetic", "sql": "SELECT c_utinyint * c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_utinyint * c_smallint", "category": "arithmetic", "sql": "SELECT c_utinyint * c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_utinyint * c_integer", "category": "arithmetic", "sql": "SELECT c_utinyint * c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_utinyint * c_bigint", "category": "arithmetic", "sql": "SELECT c_utinyint * c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_utinyint * c_hugeint", "category": "arithmetic", "sql": "SELECT c_utinyint * c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_utinyint * c_utinyint", "category": "arithmetic", "sql": "SELECT c_utinyint * c_utinyint AS v FROM t", "type": "UTINYINT"}, + {"id": "arithmetic: c_utinyint * c_usmallint", "category": "arithmetic", "sql": "SELECT c_utinyint * c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_utinyint * c_uinteger", "category": "arithmetic", "sql": "SELECT c_utinyint * c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_utinyint * c_ubigint", "category": "arithmetic", "sql": "SELECT c_utinyint * c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_utinyint * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_utinyint * c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_utinyint * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_utinyint * c_dec4_1 AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_utinyint * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_utinyint * c_dec9_2 AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic: c_utinyint * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_utinyint * c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_utinyint * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_utinyint * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_utinyint * c_real", "category": "arithmetic", "sql": "SELECT c_utinyint * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_utinyint * c_double", "category": "arithmetic", "sql": "SELECT c_utinyint * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint * c_tinyint", "category": "arithmetic", "sql": "SELECT c_usmallint * c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint * c_smallint", "category": "arithmetic", "sql": "SELECT c_usmallint * c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint * c_integer", "category": "arithmetic", "sql": "SELECT c_usmallint * c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_usmallint * c_bigint", "category": "arithmetic", "sql": "SELECT c_usmallint * c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint * c_hugeint", "category": "arithmetic", "sql": "SELECT c_usmallint * c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_usmallint * c_utinyint", "category": "arithmetic", "sql": "SELECT c_usmallint * c_utinyint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_usmallint * c_usmallint", "category": "arithmetic", "sql": "SELECT c_usmallint * c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_usmallint * c_uinteger", "category": "arithmetic", "sql": "SELECT c_usmallint * c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_usmallint * c_ubigint", "category": "arithmetic", "sql": "SELECT c_usmallint * c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_usmallint * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_usmallint * c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_usmallint * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_usmallint * c_dec4_1 AS v FROM t", "type": "DECIMAL(9,1)"}, + {"id": "arithmetic: c_usmallint * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_usmallint * c_dec9_2 AS v FROM t", "type": "DECIMAL(14,2)"}, + {"id": "arithmetic: c_usmallint * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_usmallint * c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_usmallint * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_usmallint * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_usmallint * c_real", "category": "arithmetic", "sql": "SELECT c_usmallint * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_usmallint * c_double", "category": "arithmetic", "sql": "SELECT c_usmallint * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger * c_tinyint", "category": "arithmetic", "sql": "SELECT c_uinteger * c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger * c_smallint", "category": "arithmetic", "sql": "SELECT c_uinteger * c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger * c_integer", "category": "arithmetic", "sql": "SELECT c_uinteger * c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger * c_bigint", "category": "arithmetic", "sql": "SELECT c_uinteger * c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger * c_hugeint", "category": "arithmetic", "sql": "SELECT c_uinteger * c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_uinteger * c_utinyint", "category": "arithmetic", "sql": "SELECT c_uinteger * c_utinyint AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger * c_usmallint", "category": "arithmetic", "sql": "SELECT c_uinteger * c_usmallint AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger * c_uinteger", "category": "arithmetic", "sql": "SELECT c_uinteger * c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger * c_ubigint", "category": "arithmetic", "sql": "SELECT c_uinteger * c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_uinteger * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uinteger * c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uinteger * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uinteger * c_dec4_1 AS v FROM t", "type": "DECIMAL(14,1)"}, + {"id": "arithmetic: c_uinteger * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uinteger * c_dec9_2 AS v FROM t", "type": "DECIMAL(18,2)"}, + {"id": "arithmetic: c_uinteger * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uinteger * c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_uinteger * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uinteger * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_uinteger * c_real", "category": "arithmetic", "sql": "SELECT c_uinteger * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uinteger * c_double", "category": "arithmetic", "sql": "SELECT c_uinteger * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint * c_tinyint", "category": "arithmetic", "sql": "SELECT c_ubigint * c_tinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint * c_smallint", "category": "arithmetic", "sql": "SELECT c_ubigint * c_smallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint * c_integer", "category": "arithmetic", "sql": "SELECT c_ubigint * c_integer AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint * c_bigint", "category": "arithmetic", "sql": "SELECT c_ubigint * c_bigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint * c_hugeint", "category": "arithmetic", "sql": "SELECT c_ubigint * c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint * c_utinyint", "category": "arithmetic", "sql": "SELECT c_ubigint * c_utinyint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint * c_usmallint", "category": "arithmetic", "sql": "SELECT c_ubigint * c_usmallint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint * c_uinteger", "category": "arithmetic", "sql": "SELECT c_ubigint * c_uinteger AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint * c_ubigint", "category": "arithmetic", "sql": "SELECT c_ubigint * c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_ubigint * c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_ubigint * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_ubigint * c_dec4_1 AS v FROM t", "type": "DECIMAL(24,1)"}, + {"id": "arithmetic: c_ubigint * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_ubigint * c_dec9_2 AS v FROM t", "type": "DECIMAL(29,2)"}, + {"id": "arithmetic: c_ubigint * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_ubigint * c_dec18_4 AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_ubigint * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_ubigint * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_ubigint * c_real", "category": "arithmetic", "sql": "SELECT c_ubigint * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_ubigint * c_double", "category": "arithmetic", "sql": "SELECT c_ubigint * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint * c_tinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint * c_smallint", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint * c_integer", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint * c_bigint", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint * c_hugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint * c_utinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_utinyint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint * c_usmallint", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_usmallint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint * c_uinteger", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_uinteger AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint * c_ubigint", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_ubigint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_dec4_1 AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_uhugeint * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_dec9_2 AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_uhugeint * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_dec18_4 AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_uhugeint * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_uhugeint * c_real", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uhugeint * c_double", "category": "arithmetic", "sql": "SELECT c_uhugeint * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 * c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_tinyint AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_dec4_1 * c_smallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_smallint AS v FROM t", "type": "DECIMAL(9,1)"}, + {"id": "arithmetic: c_dec4_1 * c_integer", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_integer AS v FROM t", "type": "DECIMAL(14,1)"}, + {"id": "arithmetic: c_dec4_1 * c_bigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_bigint AS v FROM t", "type": "DECIMAL(23,1)"}, + {"id": "arithmetic: c_dec4_1 * c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_hugeint AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_dec4_1 * c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_utinyint AS v FROM t", "type": "DECIMAL(7,1)"}, + {"id": "arithmetic: c_dec4_1 * c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_usmallint AS v FROM t", "type": "DECIMAL(9,1)"}, + {"id": "arithmetic: c_dec4_1 * c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_uinteger AS v FROM t", "type": "DECIMAL(14,1)"}, + {"id": "arithmetic: c_dec4_1 * c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_ubigint AS v FROM t", "type": "DECIMAL(24,1)"}, + {"id": "arithmetic: c_dec4_1 * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_uhugeint AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "arithmetic: c_dec4_1 * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_dec4_1 AS v FROM t", "type": "DECIMAL(8,2)"}, + {"id": "arithmetic: c_dec4_1 * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_dec9_2 AS v FROM t", "type": "DECIMAL(13,3)"}, + {"id": "arithmetic: c_dec4_1 * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_dec18_4 AS v FROM t", "type": "DECIMAL(18,5)"}, + {"id": "arithmetic: c_dec4_1 * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,11)"}, + {"id": "arithmetic: c_dec4_1 * c_real", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec4_1 * c_double", "category": "arithmetic", "sql": "SELECT c_dec4_1 * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 * c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_tinyint AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic: c_dec9_2 * c_smallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_smallint AS v FROM t", "type": "DECIMAL(14,2)"}, + {"id": "arithmetic: c_dec9_2 * c_integer", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_integer AS v FROM t", "type": "DECIMAL(18,2)"}, + {"id": "arithmetic: c_dec9_2 * c_bigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_bigint AS v FROM t", "type": "DECIMAL(28,2)"}, + {"id": "arithmetic: c_dec9_2 * c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_hugeint AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_dec9_2 * c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_utinyint AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic: c_dec9_2 * c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_usmallint AS v FROM t", "type": "DECIMAL(14,2)"}, + {"id": "arithmetic: c_dec9_2 * c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_uinteger AS v FROM t", "type": "DECIMAL(18,2)"}, + {"id": "arithmetic: c_dec9_2 * c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_ubigint AS v FROM t", "type": "DECIMAL(29,2)"}, + {"id": "arithmetic: c_dec9_2 * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_uhugeint AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "arithmetic: c_dec9_2 * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_dec4_1 AS v FROM t", "type": "DECIMAL(13,3)"}, + {"id": "arithmetic: c_dec9_2 * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_dec9_2 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec9_2 * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_dec18_4 AS v FROM t", "type": "DECIMAL(18,6)"}, + {"id": "arithmetic: c_dec9_2 * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,12)"}, + {"id": "arithmetic: c_dec9_2 * c_real", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec9_2 * c_double", "category": "arithmetic", "sql": "SELECT c_dec9_2 * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 * c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_tinyint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 * c_smallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_smallint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 * c_integer", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_integer AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 * c_bigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_bigint AS v FROM t", "type": "DECIMAL(37,4)"}, + {"id": "arithmetic: c_dec18_4 * c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_hugeint AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_dec18_4 * c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_utinyint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 * c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_usmallint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 * c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_uinteger AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 * c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_ubigint AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_dec18_4 * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_uhugeint AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "arithmetic: c_dec18_4 * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_dec4_1 AS v FROM t", "type": "DECIMAL(18,5)"}, + {"id": "arithmetic: c_dec18_4 * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_dec9_2 AS v FROM t", "type": "DECIMAL(18,6)"}, + {"id": "arithmetic: c_dec18_4 * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_dec18_4 AS v FROM t", "type": "DECIMAL(18,8)"}, + {"id": "arithmetic: c_dec18_4 * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,14)"}, + {"id": "arithmetic: c_dec18_4 * c_real", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec18_4 * c_double", "category": "arithmetic", "sql": "SELECT c_dec18_4 * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 * c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_tinyint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 * c_smallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_smallint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 * c_integer", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_integer AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 * c_bigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_bigint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 * c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_hugeint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 * c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_utinyint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 * c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_usmallint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 * c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_uinteger AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 * c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_ubigint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_uhugeint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_dec4_1 AS v FROM t", "type": "DECIMAL(38,11)"}, + {"id": "arithmetic: c_dec38_10 * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_dec9_2 AS v FROM t", "type": "DECIMAL(38,12)"}, + {"id": "arithmetic: c_dec38_10 * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_dec18_4 AS v FROM t", "type": "DECIMAL(38,14)"}, + {"id": "arithmetic: c_dec38_10 * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_dec38_10 AS v FROM t", "type": "DECIMAL(38,20)"}, + {"id": "arithmetic: c_dec38_10 * c_real", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec38_10 * c_double", "category": "arithmetic", "sql": "SELECT c_dec38_10 * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_real * c_tinyint", "category": "arithmetic", "sql": "SELECT c_real * c_tinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_smallint", "category": "arithmetic", "sql": "SELECT c_real * c_smallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_integer", "category": "arithmetic", "sql": "SELECT c_real * c_integer AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_bigint", "category": "arithmetic", "sql": "SELECT c_real * c_bigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_hugeint", "category": "arithmetic", "sql": "SELECT c_real * c_hugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_utinyint", "category": "arithmetic", "sql": "SELECT c_real * c_utinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_usmallint", "category": "arithmetic", "sql": "SELECT c_real * c_usmallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_uinteger", "category": "arithmetic", "sql": "SELECT c_real * c_uinteger AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_ubigint", "category": "arithmetic", "sql": "SELECT c_real * c_ubigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_real * c_uhugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_real * c_dec4_1 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_real * c_dec9_2 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_real * c_dec18_4 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_real * c_dec38_10 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_real", "category": "arithmetic", "sql": "SELECT c_real * c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real * c_double", "category": "arithmetic", "sql": "SELECT c_real * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_tinyint", "category": "arithmetic", "sql": "SELECT c_double * c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_smallint", "category": "arithmetic", "sql": "SELECT c_double * c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_integer", "category": "arithmetic", "sql": "SELECT c_double * c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_bigint", "category": "arithmetic", "sql": "SELECT c_double * c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_hugeint", "category": "arithmetic", "sql": "SELECT c_double * c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_utinyint", "category": "arithmetic", "sql": "SELECT c_double * c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_usmallint", "category": "arithmetic", "sql": "SELECT c_double * c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_uinteger", "category": "arithmetic", "sql": "SELECT c_double * c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_ubigint", "category": "arithmetic", "sql": "SELECT c_double * c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_uhugeint", "category": "arithmetic", "sql": "SELECT c_double * c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_dec4_1", "category": "arithmetic", "sql": "SELECT c_double * c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_dec9_2", "category": "arithmetic", "sql": "SELECT c_double * c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_dec18_4", "category": "arithmetic", "sql": "SELECT c_double * c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_dec38_10", "category": "arithmetic", "sql": "SELECT c_double * c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_real", "category": "arithmetic", "sql": "SELECT c_double * c_real AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double * c_double", "category": "arithmetic", "sql": "SELECT c_double * c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_tinyint", "category": "arithmetic", "sql": "SELECT c_tinyint / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_smallint", "category": "arithmetic", "sql": "SELECT c_tinyint / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_integer", "category": "arithmetic", "sql": "SELECT c_tinyint / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_bigint", "category": "arithmetic", "sql": "SELECT c_tinyint / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_hugeint", "category": "arithmetic", "sql": "SELECT c_tinyint / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_utinyint", "category": "arithmetic", "sql": "SELECT c_tinyint / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_usmallint", "category": "arithmetic", "sql": "SELECT c_tinyint / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_uinteger", "category": "arithmetic", "sql": "SELECT c_tinyint / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_ubigint", "category": "arithmetic", "sql": "SELECT c_tinyint / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_tinyint / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_tinyint / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_tinyint / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_tinyint / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_tinyint / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint / c_real", "category": "arithmetic", "sql": "SELECT c_tinyint / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_tinyint / c_double", "category": "arithmetic", "sql": "SELECT c_tinyint / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_tinyint", "category": "arithmetic", "sql": "SELECT c_smallint / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_integer", "category": "arithmetic", "sql": "SELECT c_smallint / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_hugeint", "category": "arithmetic", "sql": "SELECT c_smallint / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_utinyint", "category": "arithmetic", "sql": "SELECT c_smallint / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_usmallint", "category": "arithmetic", "sql": "SELECT c_smallint / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_uinteger", "category": "arithmetic", "sql": "SELECT c_smallint / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_ubigint", "category": "arithmetic", "sql": "SELECT c_smallint / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_smallint / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_smallint / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_smallint / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_smallint / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_smallint / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint / c_real", "category": "arithmetic", "sql": "SELECT c_smallint / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_smallint / c_double", "category": "arithmetic", "sql": "SELECT c_smallint / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_tinyint", "category": "arithmetic", "sql": "SELECT c_integer / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_smallint", "category": "arithmetic", "sql": "SELECT c_integer / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_integer", "category": "arithmetic", "sql": "SELECT c_integer / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_bigint", "category": "arithmetic", "sql": "SELECT c_integer / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_hugeint", "category": "arithmetic", "sql": "SELECT c_integer / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_utinyint", "category": "arithmetic", "sql": "SELECT c_integer / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_usmallint", "category": "arithmetic", "sql": "SELECT c_integer / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_uinteger", "category": "arithmetic", "sql": "SELECT c_integer / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_ubigint", "category": "arithmetic", "sql": "SELECT c_integer / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_integer / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_integer / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_integer / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_integer / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_integer / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer / c_real", "category": "arithmetic", "sql": "SELECT c_integer / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_integer / c_double", "category": "arithmetic", "sql": "SELECT c_integer / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_tinyint", "category": "arithmetic", "sql": "SELECT c_bigint / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_integer", "category": "arithmetic", "sql": "SELECT c_bigint / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_hugeint", "category": "arithmetic", "sql": "SELECT c_bigint / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_utinyint", "category": "arithmetic", "sql": "SELECT c_bigint / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_usmallint", "category": "arithmetic", "sql": "SELECT c_bigint / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_uinteger", "category": "arithmetic", "sql": "SELECT c_bigint / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_ubigint", "category": "arithmetic", "sql": "SELECT c_bigint / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_bigint / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_bigint / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_bigint / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_bigint / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_bigint / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint / c_real", "category": "arithmetic", "sql": "SELECT c_bigint / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_bigint / c_double", "category": "arithmetic", "sql": "SELECT c_bigint / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_tinyint", "category": "arithmetic", "sql": "SELECT c_hugeint / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_smallint", "category": "arithmetic", "sql": "SELECT c_hugeint / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_integer", "category": "arithmetic", "sql": "SELECT c_hugeint / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_bigint", "category": "arithmetic", "sql": "SELECT c_hugeint / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_hugeint", "category": "arithmetic", "sql": "SELECT c_hugeint / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_utinyint", "category": "arithmetic", "sql": "SELECT c_hugeint / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_usmallint", "category": "arithmetic", "sql": "SELECT c_hugeint / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_uinteger", "category": "arithmetic", "sql": "SELECT c_hugeint / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_ubigint", "category": "arithmetic", "sql": "SELECT c_hugeint / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_hugeint / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_hugeint / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_hugeint / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_hugeint / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_hugeint / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint / c_real", "category": "arithmetic", "sql": "SELECT c_hugeint / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_hugeint / c_double", "category": "arithmetic", "sql": "SELECT c_hugeint / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_tinyint", "category": "arithmetic", "sql": "SELECT c_utinyint / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_smallint", "category": "arithmetic", "sql": "SELECT c_utinyint / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_integer", "category": "arithmetic", "sql": "SELECT c_utinyint / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_bigint", "category": "arithmetic", "sql": "SELECT c_utinyint / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_hugeint", "category": "arithmetic", "sql": "SELECT c_utinyint / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_utinyint", "category": "arithmetic", "sql": "SELECT c_utinyint / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_usmallint", "category": "arithmetic", "sql": "SELECT c_utinyint / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_uinteger", "category": "arithmetic", "sql": "SELECT c_utinyint / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_ubigint", "category": "arithmetic", "sql": "SELECT c_utinyint / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_utinyint / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_utinyint / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_utinyint / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_utinyint / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_utinyint / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint / c_real", "category": "arithmetic", "sql": "SELECT c_utinyint / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_utinyint / c_double", "category": "arithmetic", "sql": "SELECT c_utinyint / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_tinyint", "category": "arithmetic", "sql": "SELECT c_usmallint / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_smallint", "category": "arithmetic", "sql": "SELECT c_usmallint / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_integer", "category": "arithmetic", "sql": "SELECT c_usmallint / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_bigint", "category": "arithmetic", "sql": "SELECT c_usmallint / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_hugeint", "category": "arithmetic", "sql": "SELECT c_usmallint / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_utinyint", "category": "arithmetic", "sql": "SELECT c_usmallint / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_usmallint", "category": "arithmetic", "sql": "SELECT c_usmallint / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_uinteger", "category": "arithmetic", "sql": "SELECT c_usmallint / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_ubigint", "category": "arithmetic", "sql": "SELECT c_usmallint / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_usmallint / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_usmallint / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_usmallint / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_usmallint / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_usmallint / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint / c_real", "category": "arithmetic", "sql": "SELECT c_usmallint / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_usmallint / c_double", "category": "arithmetic", "sql": "SELECT c_usmallint / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_tinyint", "category": "arithmetic", "sql": "SELECT c_uinteger / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_smallint", "category": "arithmetic", "sql": "SELECT c_uinteger / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_integer", "category": "arithmetic", "sql": "SELECT c_uinteger / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_bigint", "category": "arithmetic", "sql": "SELECT c_uinteger / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_hugeint", "category": "arithmetic", "sql": "SELECT c_uinteger / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_utinyint", "category": "arithmetic", "sql": "SELECT c_uinteger / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_usmallint", "category": "arithmetic", "sql": "SELECT c_uinteger / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_uinteger", "category": "arithmetic", "sql": "SELECT c_uinteger / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_ubigint", "category": "arithmetic", "sql": "SELECT c_uinteger / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uinteger / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uinteger / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uinteger / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uinteger / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uinteger / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger / c_real", "category": "arithmetic", "sql": "SELECT c_uinteger / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uinteger / c_double", "category": "arithmetic", "sql": "SELECT c_uinteger / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_tinyint", "category": "arithmetic", "sql": "SELECT c_ubigint / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_smallint", "category": "arithmetic", "sql": "SELECT c_ubigint / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_integer", "category": "arithmetic", "sql": "SELECT c_ubigint / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_bigint", "category": "arithmetic", "sql": "SELECT c_ubigint / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_hugeint", "category": "arithmetic", "sql": "SELECT c_ubigint / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_utinyint", "category": "arithmetic", "sql": "SELECT c_ubigint / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_usmallint", "category": "arithmetic", "sql": "SELECT c_ubigint / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_uinteger", "category": "arithmetic", "sql": "SELECT c_ubigint / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_ubigint", "category": "arithmetic", "sql": "SELECT c_ubigint / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_ubigint / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_ubigint / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_ubigint / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_ubigint / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_ubigint / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint / c_real", "category": "arithmetic", "sql": "SELECT c_ubigint / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_ubigint / c_double", "category": "arithmetic", "sql": "SELECT c_ubigint / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_tinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_smallint", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_integer", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_bigint", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_hugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_utinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_usmallint", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_uinteger", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_ubigint", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint / c_real", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uhugeint / c_double", "category": "arithmetic", "sql": "SELECT c_uhugeint / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_smallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_integer", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_bigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 / c_real", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec4_1 / c_double", "category": "arithmetic", "sql": "SELECT c_dec4_1 / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_smallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_integer", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_bigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 / c_real", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec9_2 / c_double", "category": "arithmetic", "sql": "SELECT c_dec9_2 / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_smallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_integer", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_bigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 / c_real", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec18_4 / c_double", "category": "arithmetic", "sql": "SELECT c_dec18_4 / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_smallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_integer", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_bigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 / c_real", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec38_10 / c_double", "category": "arithmetic", "sql": "SELECT c_dec38_10 / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_real / c_tinyint", "category": "arithmetic", "sql": "SELECT c_real / c_tinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_smallint", "category": "arithmetic", "sql": "SELECT c_real / c_smallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_integer", "category": "arithmetic", "sql": "SELECT c_real / c_integer AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_bigint", "category": "arithmetic", "sql": "SELECT c_real / c_bigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_hugeint", "category": "arithmetic", "sql": "SELECT c_real / c_hugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_utinyint", "category": "arithmetic", "sql": "SELECT c_real / c_utinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_usmallint", "category": "arithmetic", "sql": "SELECT c_real / c_usmallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_uinteger", "category": "arithmetic", "sql": "SELECT c_real / c_uinteger AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_ubigint", "category": "arithmetic", "sql": "SELECT c_real / c_ubigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_real / c_uhugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_real / c_dec4_1 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_real / c_dec9_2 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_real / c_dec18_4 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_real / c_dec38_10 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_real", "category": "arithmetic", "sql": "SELECT c_real / c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real / c_double", "category": "arithmetic", "sql": "SELECT c_real / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_tinyint", "category": "arithmetic", "sql": "SELECT c_double / c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_smallint", "category": "arithmetic", "sql": "SELECT c_double / c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_integer", "category": "arithmetic", "sql": "SELECT c_double / c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_bigint", "category": "arithmetic", "sql": "SELECT c_double / c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_hugeint", "category": "arithmetic", "sql": "SELECT c_double / c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_utinyint", "category": "arithmetic", "sql": "SELECT c_double / c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_usmallint", "category": "arithmetic", "sql": "SELECT c_double / c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_uinteger", "category": "arithmetic", "sql": "SELECT c_double / c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_ubigint", "category": "arithmetic", "sql": "SELECT c_double / c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_uhugeint", "category": "arithmetic", "sql": "SELECT c_double / c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_dec4_1", "category": "arithmetic", "sql": "SELECT c_double / c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_dec9_2", "category": "arithmetic", "sql": "SELECT c_double / c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_dec18_4", "category": "arithmetic", "sql": "SELECT c_double / c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_dec38_10", "category": "arithmetic", "sql": "SELECT c_double / c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_real", "category": "arithmetic", "sql": "SELECT c_double / c_real AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double / c_double", "category": "arithmetic", "sql": "SELECT c_double / c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint % c_tinyint", "category": "arithmetic", "sql": "SELECT c_tinyint % c_tinyint AS v FROM t", "type": "TINYINT"}, + {"id": "arithmetic: c_tinyint % c_smallint", "category": "arithmetic", "sql": "SELECT c_tinyint % c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_tinyint % c_integer", "category": "arithmetic", "sql": "SELECT c_tinyint % c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_tinyint % c_bigint", "category": "arithmetic", "sql": "SELECT c_tinyint % c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint % c_hugeint", "category": "arithmetic", "sql": "SELECT c_tinyint % c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_tinyint % c_utinyint", "category": "arithmetic", "sql": "SELECT c_tinyint % c_utinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint % c_usmallint", "category": "arithmetic", "sql": "SELECT c_tinyint % c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint % c_uinteger", "category": "arithmetic", "sql": "SELECT c_tinyint % c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint % c_ubigint", "category": "arithmetic", "sql": "SELECT c_tinyint % c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_tinyint % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_tinyint % c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_tinyint % c_dec4_1 AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "arithmetic: c_tinyint % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_tinyint % c_dec9_2 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_tinyint % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_tinyint % c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_tinyint % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_tinyint % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_tinyint % c_real", "category": "arithmetic", "sql": "SELECT c_tinyint % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_tinyint % c_double", "category": "arithmetic", "sql": "SELECT c_tinyint % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint % c_tinyint", "category": "arithmetic", "sql": "SELECT c_smallint % c_tinyint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint % c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint % c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint % c_integer", "category": "arithmetic", "sql": "SELECT c_smallint % c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_smallint % c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint % c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint % c_hugeint", "category": "arithmetic", "sql": "SELECT c_smallint % c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_smallint % c_utinyint", "category": "arithmetic", "sql": "SELECT c_smallint % c_utinyint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint % c_usmallint", "category": "arithmetic", "sql": "SELECT c_smallint % c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint % c_uinteger", "category": "arithmetic", "sql": "SELECT c_smallint % c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint % c_ubigint", "category": "arithmetic", "sql": "SELECT c_smallint % c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_smallint % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_smallint % c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_smallint % c_dec4_1 AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "arithmetic: c_smallint % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_smallint % c_dec9_2 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_smallint % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_smallint % c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_smallint % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_smallint % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_smallint % c_real", "category": "arithmetic", "sql": "SELECT c_smallint % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_smallint % c_double", "category": "arithmetic", "sql": "SELECT c_smallint % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer % c_tinyint", "category": "arithmetic", "sql": "SELECT c_integer % c_tinyint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer % c_smallint", "category": "arithmetic", "sql": "SELECT c_integer % c_smallint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer % c_integer", "category": "arithmetic", "sql": "SELECT c_integer % c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer % c_bigint", "category": "arithmetic", "sql": "SELECT c_integer % c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_integer % c_hugeint", "category": "arithmetic", "sql": "SELECT c_integer % c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_integer % c_utinyint", "category": "arithmetic", "sql": "SELECT c_integer % c_utinyint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer % c_usmallint", "category": "arithmetic", "sql": "SELECT c_integer % c_usmallint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer % c_uinteger", "category": "arithmetic", "sql": "SELECT c_integer % c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_integer % c_ubigint", "category": "arithmetic", "sql": "SELECT c_integer % c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_integer % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_integer % c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_integer % c_dec4_1 AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "arithmetic: c_integer % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_integer % c_dec9_2 AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic: c_integer % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_integer % c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_integer % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_integer % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_integer % c_real", "category": "arithmetic", "sql": "SELECT c_integer % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_integer % c_double", "category": "arithmetic", "sql": "SELECT c_integer % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint % c_tinyint", "category": "arithmetic", "sql": "SELECT c_bigint % c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint % c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint % c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint % c_integer", "category": "arithmetic", "sql": "SELECT c_bigint % c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint % c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint % c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint % c_hugeint", "category": "arithmetic", "sql": "SELECT c_bigint % c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_bigint % c_utinyint", "category": "arithmetic", "sql": "SELECT c_bigint % c_utinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint % c_usmallint", "category": "arithmetic", "sql": "SELECT c_bigint % c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint % c_uinteger", "category": "arithmetic", "sql": "SELECT c_bigint % c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint % c_ubigint", "category": "arithmetic", "sql": "SELECT c_bigint % c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_bigint % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_bigint % c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_bigint % c_dec4_1 AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "arithmetic: c_bigint % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_bigint % c_dec9_2 AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "arithmetic: c_bigint % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_bigint % c_dec18_4 AS v FROM t", "type": "DECIMAL(23,4)"}, + {"id": "arithmetic: c_bigint % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_bigint % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_bigint % c_real", "category": "arithmetic", "sql": "SELECT c_bigint % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_bigint % c_double", "category": "arithmetic", "sql": "SELECT c_bigint % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint % c_tinyint", "category": "arithmetic", "sql": "SELECT c_hugeint % c_tinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint % c_smallint", "category": "arithmetic", "sql": "SELECT c_hugeint % c_smallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint % c_integer", "category": "arithmetic", "sql": "SELECT c_hugeint % c_integer AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint % c_bigint", "category": "arithmetic", "sql": "SELECT c_hugeint % c_bigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint % c_hugeint", "category": "arithmetic", "sql": "SELECT c_hugeint % c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint % c_utinyint", "category": "arithmetic", "sql": "SELECT c_hugeint % c_utinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint % c_usmallint", "category": "arithmetic", "sql": "SELECT c_hugeint % c_usmallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint % c_uinteger", "category": "arithmetic", "sql": "SELECT c_hugeint % c_uinteger AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint % c_ubigint", "category": "arithmetic", "sql": "SELECT c_hugeint % c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_hugeint % c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_hugeint % c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_hugeint % c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_hugeint % c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_hugeint % c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint % c_real", "category": "arithmetic", "sql": "SELECT c_hugeint % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_hugeint % c_double", "category": "arithmetic", "sql": "SELECT c_hugeint % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint % c_tinyint", "category": "arithmetic", "sql": "SELECT c_utinyint % c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_utinyint % c_smallint", "category": "arithmetic", "sql": "SELECT c_utinyint % c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_utinyint % c_integer", "category": "arithmetic", "sql": "SELECT c_utinyint % c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_utinyint % c_bigint", "category": "arithmetic", "sql": "SELECT c_utinyint % c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_utinyint % c_hugeint", "category": "arithmetic", "sql": "SELECT c_utinyint % c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_utinyint % c_utinyint", "category": "arithmetic", "sql": "SELECT c_utinyint % c_utinyint AS v FROM t", "type": "UTINYINT"}, + {"id": "arithmetic: c_utinyint % c_usmallint", "category": "arithmetic", "sql": "SELECT c_utinyint % c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_utinyint % c_uinteger", "category": "arithmetic", "sql": "SELECT c_utinyint % c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_utinyint % c_ubigint", "category": "arithmetic", "sql": "SELECT c_utinyint % c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_utinyint % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_utinyint % c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_utinyint % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_utinyint % c_dec4_1 AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "arithmetic: c_utinyint % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_utinyint % c_dec9_2 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_utinyint % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_utinyint % c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_utinyint % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_utinyint % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_utinyint % c_real", "category": "arithmetic", "sql": "SELECT c_utinyint % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_utinyint % c_double", "category": "arithmetic", "sql": "SELECT c_utinyint % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint % c_tinyint", "category": "arithmetic", "sql": "SELECT c_usmallint % c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint % c_smallint", "category": "arithmetic", "sql": "SELECT c_usmallint % c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint % c_integer", "category": "arithmetic", "sql": "SELECT c_usmallint % c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_usmallint % c_bigint", "category": "arithmetic", "sql": "SELECT c_usmallint % c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint % c_hugeint", "category": "arithmetic", "sql": "SELECT c_usmallint % c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_usmallint % c_utinyint", "category": "arithmetic", "sql": "SELECT c_usmallint % c_utinyint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_usmallint % c_usmallint", "category": "arithmetic", "sql": "SELECT c_usmallint % c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_usmallint % c_uinteger", "category": "arithmetic", "sql": "SELECT c_usmallint % c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_usmallint % c_ubigint", "category": "arithmetic", "sql": "SELECT c_usmallint % c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_usmallint % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_usmallint % c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_usmallint % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_usmallint % c_dec4_1 AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "arithmetic: c_usmallint % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_usmallint % c_dec9_2 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_usmallint % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_usmallint % c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_usmallint % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_usmallint % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_usmallint % c_real", "category": "arithmetic", "sql": "SELECT c_usmallint % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_usmallint % c_double", "category": "arithmetic", "sql": "SELECT c_usmallint % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger % c_tinyint", "category": "arithmetic", "sql": "SELECT c_uinteger % c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger % c_smallint", "category": "arithmetic", "sql": "SELECT c_uinteger % c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger % c_integer", "category": "arithmetic", "sql": "SELECT c_uinteger % c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger % c_bigint", "category": "arithmetic", "sql": "SELECT c_uinteger % c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger % c_hugeint", "category": "arithmetic", "sql": "SELECT c_uinteger % c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_uinteger % c_utinyint", "category": "arithmetic", "sql": "SELECT c_uinteger % c_utinyint AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger % c_usmallint", "category": "arithmetic", "sql": "SELECT c_uinteger % c_usmallint AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger % c_uinteger", "category": "arithmetic", "sql": "SELECT c_uinteger % c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger % c_ubigint", "category": "arithmetic", "sql": "SELECT c_uinteger % c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_uinteger % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uinteger % c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uinteger % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uinteger % c_dec4_1 AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "arithmetic: c_uinteger % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uinteger % c_dec9_2 AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic: c_uinteger % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uinteger % c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_uinteger % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uinteger % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_uinteger % c_real", "category": "arithmetic", "sql": "SELECT c_uinteger % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uinteger % c_double", "category": "arithmetic", "sql": "SELECT c_uinteger % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint % c_tinyint", "category": "arithmetic", "sql": "SELECT c_ubigint % c_tinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint % c_smallint", "category": "arithmetic", "sql": "SELECT c_ubigint % c_smallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint % c_integer", "category": "arithmetic", "sql": "SELECT c_ubigint % c_integer AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint % c_bigint", "category": "arithmetic", "sql": "SELECT c_ubigint % c_bigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint % c_hugeint", "category": "arithmetic", "sql": "SELECT c_ubigint % c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint % c_utinyint", "category": "arithmetic", "sql": "SELECT c_ubigint % c_utinyint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint % c_usmallint", "category": "arithmetic", "sql": "SELECT c_ubigint % c_usmallint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint % c_uinteger", "category": "arithmetic", "sql": "SELECT c_ubigint % c_uinteger AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint % c_ubigint", "category": "arithmetic", "sql": "SELECT c_ubigint % c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_ubigint % c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_ubigint % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_ubigint % c_dec4_1 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic: c_ubigint % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_ubigint % c_dec9_2 AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic: c_ubigint % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_ubigint % c_dec18_4 AS v FROM t", "type": "DECIMAL(24,4)"}, + {"id": "arithmetic: c_ubigint % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_ubigint % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_ubigint % c_real", "category": "arithmetic", "sql": "SELECT c_ubigint % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_ubigint % c_double", "category": "arithmetic", "sql": "SELECT c_ubigint % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint % c_tinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint % c_smallint", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint % c_integer", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint % c_bigint", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint % c_hugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint % c_utinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_utinyint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint % c_usmallint", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_usmallint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint % c_uinteger", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_uinteger AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint % c_ubigint", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_ubigint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint % c_real", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uhugeint % c_double", "category": "arithmetic", "sql": "SELECT c_uhugeint % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 % c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_tinyint AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "arithmetic: c_dec4_1 % c_smallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_smallint AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "arithmetic: c_dec4_1 % c_integer", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_integer AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "arithmetic: c_dec4_1 % c_bigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_bigint AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "arithmetic: c_dec4_1 % c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 % c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_utinyint AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "arithmetic: c_dec4_1 % c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_usmallint AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "arithmetic: c_dec4_1 % c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_uinteger AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "arithmetic: c_dec4_1 % c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_ubigint AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic: c_dec4_1 % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_dec4_1 AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "arithmetic: c_dec4_1 % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_dec9_2 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_dec4_1 % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec4_1 % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec4_1 % c_real", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec4_1 % c_double", "category": "arithmetic", "sql": "SELECT c_dec4_1 % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 % c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_tinyint AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_dec9_2 % c_smallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_smallint AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_dec9_2 % c_integer", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_integer AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic: c_dec9_2 % c_bigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_bigint AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "arithmetic: c_dec9_2 % c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 % c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_utinyint AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_dec9_2 % c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_usmallint AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_dec9_2 % c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_uinteger AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic: c_dec9_2 % c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_ubigint AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic: c_dec9_2 % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_dec4_1 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_dec9_2 % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_dec9_2 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic: c_dec9_2 % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec9_2 % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec9_2 % c_real", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec9_2 % c_double", "category": "arithmetic", "sql": "SELECT c_dec9_2 % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 % c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_tinyint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 % c_smallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_smallint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 % c_integer", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_integer AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 % c_bigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_bigint AS v FROM t", "type": "DECIMAL(23,4)"}, + {"id": "arithmetic: c_dec18_4 % c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 % c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_utinyint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 % c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_usmallint AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 % c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_uinteger AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 % c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_ubigint AS v FROM t", "type": "DECIMAL(24,4)"}, + {"id": "arithmetic: c_dec18_4 % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_dec4_1 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_dec9_2 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic: c_dec18_4 % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec18_4 % c_real", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec18_4 % c_double", "category": "arithmetic", "sql": "SELECT c_dec18_4 % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 % c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_tinyint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_smallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_smallint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_integer", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_integer AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_bigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_bigint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 % c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_utinyint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_usmallint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_uinteger AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_ubigint AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_dec4_1 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_dec9_2 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_dec18_4 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic: c_dec38_10 % c_real", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec38_10 % c_double", "category": "arithmetic", "sql": "SELECT c_dec38_10 % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_real % c_tinyint", "category": "arithmetic", "sql": "SELECT c_real % c_tinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_smallint", "category": "arithmetic", "sql": "SELECT c_real % c_smallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_integer", "category": "arithmetic", "sql": "SELECT c_real % c_integer AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_bigint", "category": "arithmetic", "sql": "SELECT c_real % c_bigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_hugeint", "category": "arithmetic", "sql": "SELECT c_real % c_hugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_utinyint", "category": "arithmetic", "sql": "SELECT c_real % c_utinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_usmallint", "category": "arithmetic", "sql": "SELECT c_real % c_usmallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_uinteger", "category": "arithmetic", "sql": "SELECT c_real % c_uinteger AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_ubigint", "category": "arithmetic", "sql": "SELECT c_real % c_ubigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_real % c_uhugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_real % c_dec4_1 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_real % c_dec9_2 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_real % c_dec18_4 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_real % c_dec38_10 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_real", "category": "arithmetic", "sql": "SELECT c_real % c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real % c_double", "category": "arithmetic", "sql": "SELECT c_real % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_tinyint", "category": "arithmetic", "sql": "SELECT c_double % c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_smallint", "category": "arithmetic", "sql": "SELECT c_double % c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_integer", "category": "arithmetic", "sql": "SELECT c_double % c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_bigint", "category": "arithmetic", "sql": "SELECT c_double % c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_hugeint", "category": "arithmetic", "sql": "SELECT c_double % c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_utinyint", "category": "arithmetic", "sql": "SELECT c_double % c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_usmallint", "category": "arithmetic", "sql": "SELECT c_double % c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_uinteger", "category": "arithmetic", "sql": "SELECT c_double % c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_ubigint", "category": "arithmetic", "sql": "SELECT c_double % c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_uhugeint", "category": "arithmetic", "sql": "SELECT c_double % c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_dec4_1", "category": "arithmetic", "sql": "SELECT c_double % c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_dec9_2", "category": "arithmetic", "sql": "SELECT c_double % c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_dec18_4", "category": "arithmetic", "sql": "SELECT c_double % c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_dec38_10", "category": "arithmetic", "sql": "SELECT c_double % c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_real", "category": "arithmetic", "sql": "SELECT c_double % c_real AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double % c_double", "category": "arithmetic", "sql": "SELECT c_double % c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint // c_tinyint", "category": "arithmetic", "sql": "SELECT c_tinyint // c_tinyint AS v FROM t", "type": "TINYINT"}, + {"id": "arithmetic: c_tinyint // c_smallint", "category": "arithmetic", "sql": "SELECT c_tinyint // c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_tinyint // c_integer", "category": "arithmetic", "sql": "SELECT c_tinyint // c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_tinyint // c_bigint", "category": "arithmetic", "sql": "SELECT c_tinyint // c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint // c_hugeint", "category": "arithmetic", "sql": "SELECT c_tinyint // c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_tinyint // c_utinyint", "category": "arithmetic", "sql": "SELECT c_tinyint // c_utinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint // c_usmallint", "category": "arithmetic", "sql": "SELECT c_tinyint // c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint // c_uinteger", "category": "arithmetic", "sql": "SELECT c_tinyint // c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_tinyint // c_ubigint", "category": "arithmetic", "sql": "SELECT c_tinyint // c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_tinyint // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_tinyint // c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_tinyint // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_tinyint // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_tinyint // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_tinyint // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_tinyint // c_real", "category": "arithmetic", "sql": "SELECT c_tinyint // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_tinyint // c_double", "category": "arithmetic", "sql": "SELECT c_tinyint // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint // c_tinyint", "category": "arithmetic", "sql": "SELECT c_smallint // c_tinyint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint // c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint // c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint // c_integer", "category": "arithmetic", "sql": "SELECT c_smallint // c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_smallint // c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint // c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint // c_hugeint", "category": "arithmetic", "sql": "SELECT c_smallint // c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_smallint // c_utinyint", "category": "arithmetic", "sql": "SELECT c_smallint // c_utinyint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_smallint // c_usmallint", "category": "arithmetic", "sql": "SELECT c_smallint // c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint // c_uinteger", "category": "arithmetic", "sql": "SELECT c_smallint // c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_smallint // c_ubigint", "category": "arithmetic", "sql": "SELECT c_smallint // c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_smallint // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_smallint // c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_smallint // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_smallint // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_smallint // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_smallint // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_smallint // c_real", "category": "arithmetic", "sql": "SELECT c_smallint // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_smallint // c_double", "category": "arithmetic", "sql": "SELECT c_smallint // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer // c_tinyint", "category": "arithmetic", "sql": "SELECT c_integer // c_tinyint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer // c_smallint", "category": "arithmetic", "sql": "SELECT c_integer // c_smallint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer // c_integer", "category": "arithmetic", "sql": "SELECT c_integer // c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer // c_bigint", "category": "arithmetic", "sql": "SELECT c_integer // c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_integer // c_hugeint", "category": "arithmetic", "sql": "SELECT c_integer // c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_integer // c_utinyint", "category": "arithmetic", "sql": "SELECT c_integer // c_utinyint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer // c_usmallint", "category": "arithmetic", "sql": "SELECT c_integer // c_usmallint AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_integer // c_uinteger", "category": "arithmetic", "sql": "SELECT c_integer // c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_integer // c_ubigint", "category": "arithmetic", "sql": "SELECT c_integer // c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_integer // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_integer // c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_integer // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_integer // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_integer // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_integer // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_integer // c_real", "category": "arithmetic", "sql": "SELECT c_integer // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_integer // c_double", "category": "arithmetic", "sql": "SELECT c_integer // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint // c_tinyint", "category": "arithmetic", "sql": "SELECT c_bigint // c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint // c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint // c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint // c_integer", "category": "arithmetic", "sql": "SELECT c_bigint // c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint // c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint // c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint // c_hugeint", "category": "arithmetic", "sql": "SELECT c_bigint // c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_bigint // c_utinyint", "category": "arithmetic", "sql": "SELECT c_bigint // c_utinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint // c_usmallint", "category": "arithmetic", "sql": "SELECT c_bigint // c_usmallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint // c_uinteger", "category": "arithmetic", "sql": "SELECT c_bigint // c_uinteger AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_bigint // c_ubigint", "category": "arithmetic", "sql": "SELECT c_bigint // c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_bigint // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_bigint // c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_bigint // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_bigint // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_bigint // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_bigint // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_bigint // c_real", "category": "arithmetic", "sql": "SELECT c_bigint // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_bigint // c_double", "category": "arithmetic", "sql": "SELECT c_bigint // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint // c_tinyint", "category": "arithmetic", "sql": "SELECT c_hugeint // c_tinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint // c_smallint", "category": "arithmetic", "sql": "SELECT c_hugeint // c_smallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint // c_integer", "category": "arithmetic", "sql": "SELECT c_hugeint // c_integer AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint // c_bigint", "category": "arithmetic", "sql": "SELECT c_hugeint // c_bigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint // c_hugeint", "category": "arithmetic", "sql": "SELECT c_hugeint // c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint // c_utinyint", "category": "arithmetic", "sql": "SELECT c_hugeint // c_utinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint // c_usmallint", "category": "arithmetic", "sql": "SELECT c_hugeint // c_usmallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint // c_uinteger", "category": "arithmetic", "sql": "SELECT c_hugeint // c_uinteger AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint // c_ubigint", "category": "arithmetic", "sql": "SELECT c_hugeint // c_ubigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_hugeint // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_hugeint // c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_hugeint // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_hugeint // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_hugeint // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_hugeint // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_hugeint // c_real", "category": "arithmetic", "sql": "SELECT c_hugeint // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_hugeint // c_double", "category": "arithmetic", "sql": "SELECT c_hugeint // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint // c_tinyint", "category": "arithmetic", "sql": "SELECT c_utinyint // c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_utinyint // c_smallint", "category": "arithmetic", "sql": "SELECT c_utinyint // c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic: c_utinyint // c_integer", "category": "arithmetic", "sql": "SELECT c_utinyint // c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_utinyint // c_bigint", "category": "arithmetic", "sql": "SELECT c_utinyint // c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_utinyint // c_hugeint", "category": "arithmetic", "sql": "SELECT c_utinyint // c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_utinyint // c_utinyint", "category": "arithmetic", "sql": "SELECT c_utinyint // c_utinyint AS v FROM t", "type": "UTINYINT"}, + {"id": "arithmetic: c_utinyint // c_usmallint", "category": "arithmetic", "sql": "SELECT c_utinyint // c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_utinyint // c_uinteger", "category": "arithmetic", "sql": "SELECT c_utinyint // c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_utinyint // c_ubigint", "category": "arithmetic", "sql": "SELECT c_utinyint // c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_utinyint // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_utinyint // c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_utinyint // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_utinyint // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_utinyint // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_utinyint // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_utinyint // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_utinyint // c_real", "category": "arithmetic", "sql": "SELECT c_utinyint // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_utinyint // c_double", "category": "arithmetic", "sql": "SELECT c_utinyint // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint // c_tinyint", "category": "arithmetic", "sql": "SELECT c_usmallint // c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint // c_smallint", "category": "arithmetic", "sql": "SELECT c_usmallint // c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint // c_integer", "category": "arithmetic", "sql": "SELECT c_usmallint // c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic: c_usmallint // c_bigint", "category": "arithmetic", "sql": "SELECT c_usmallint // c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_usmallint // c_hugeint", "category": "arithmetic", "sql": "SELECT c_usmallint // c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_usmallint // c_utinyint", "category": "arithmetic", "sql": "SELECT c_usmallint // c_utinyint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_usmallint // c_usmallint", "category": "arithmetic", "sql": "SELECT c_usmallint // c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic: c_usmallint // c_uinteger", "category": "arithmetic", "sql": "SELECT c_usmallint // c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_usmallint // c_ubigint", "category": "arithmetic", "sql": "SELECT c_usmallint // c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_usmallint // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_usmallint // c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_usmallint // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_usmallint // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_usmallint // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_usmallint // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_usmallint // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_usmallint // c_real", "category": "arithmetic", "sql": "SELECT c_usmallint // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_usmallint // c_double", "category": "arithmetic", "sql": "SELECT c_usmallint // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger // c_tinyint", "category": "arithmetic", "sql": "SELECT c_uinteger // c_tinyint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger // c_smallint", "category": "arithmetic", "sql": "SELECT c_uinteger // c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger // c_integer", "category": "arithmetic", "sql": "SELECT c_uinteger // c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger // c_bigint", "category": "arithmetic", "sql": "SELECT c_uinteger // c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic: c_uinteger // c_hugeint", "category": "arithmetic", "sql": "SELECT c_uinteger // c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_uinteger // c_utinyint", "category": "arithmetic", "sql": "SELECT c_uinteger // c_utinyint AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger // c_usmallint", "category": "arithmetic", "sql": "SELECT c_uinteger // c_usmallint AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger // c_uinteger", "category": "arithmetic", "sql": "SELECT c_uinteger // c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic: c_uinteger // c_ubigint", "category": "arithmetic", "sql": "SELECT c_uinteger // c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_uinteger // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uinteger // c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uinteger // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uinteger // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uinteger // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uinteger // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uinteger // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uinteger // c_real", "category": "arithmetic", "sql": "SELECT c_uinteger // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uinteger // c_double", "category": "arithmetic", "sql": "SELECT c_uinteger // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint // c_tinyint", "category": "arithmetic", "sql": "SELECT c_ubigint // c_tinyint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint // c_smallint", "category": "arithmetic", "sql": "SELECT c_ubigint // c_smallint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint // c_integer", "category": "arithmetic", "sql": "SELECT c_ubigint // c_integer AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint // c_bigint", "category": "arithmetic", "sql": "SELECT c_ubigint // c_bigint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint // c_hugeint", "category": "arithmetic", "sql": "SELECT c_ubigint // c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic: c_ubigint // c_utinyint", "category": "arithmetic", "sql": "SELECT c_ubigint // c_utinyint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint // c_usmallint", "category": "arithmetic", "sql": "SELECT c_ubigint // c_usmallint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint // c_uinteger", "category": "arithmetic", "sql": "SELECT c_ubigint // c_uinteger AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint // c_ubigint", "category": "arithmetic", "sql": "SELECT c_ubigint // c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic: c_ubigint // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_ubigint // c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_ubigint // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_ubigint // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_ubigint // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_ubigint // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_ubigint // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_ubigint // c_real", "category": "arithmetic", "sql": "SELECT c_ubigint // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_ubigint // c_double", "category": "arithmetic", "sql": "SELECT c_ubigint // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint // c_tinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint // c_smallint", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint // c_integer", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint // c_bigint", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint // c_hugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint // c_utinyint", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_utinyint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint // c_usmallint", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_usmallint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint // c_uinteger", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_uinteger AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint // c_ubigint", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_ubigint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic: c_uhugeint // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_uhugeint // c_real", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_uhugeint // c_double", "category": "arithmetic", "sql": "SELECT c_uhugeint // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_smallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_integer", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_bigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec4_1 // c_real", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec4_1 // c_double", "category": "arithmetic", "sql": "SELECT c_dec4_1 // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_smallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_integer", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_bigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec9_2 // c_real", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec9_2 // c_double", "category": "arithmetic", "sql": "SELECT c_dec9_2 // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_smallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_integer", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_bigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec18_4 // c_real", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec18_4 // c_double", "category": "arithmetic", "sql": "SELECT c_dec18_4 // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_tinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_smallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_integer", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_bigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_hugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_utinyint", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_usmallint", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_uinteger", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_ubigint", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_dec38_10 // c_real", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_dec38_10 // c_double", "category": "arithmetic", "sql": "SELECT c_dec38_10 // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_real // c_tinyint", "category": "arithmetic", "sql": "SELECT c_real // c_tinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_smallint", "category": "arithmetic", "sql": "SELECT c_real // c_smallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_integer", "category": "arithmetic", "sql": "SELECT c_real // c_integer AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_bigint", "category": "arithmetic", "sql": "SELECT c_real // c_bigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_hugeint", "category": "arithmetic", "sql": "SELECT c_real // c_hugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_utinyint", "category": "arithmetic", "sql": "SELECT c_real // c_utinyint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_usmallint", "category": "arithmetic", "sql": "SELECT c_real // c_usmallint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_uinteger", "category": "arithmetic", "sql": "SELECT c_real // c_uinteger AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_ubigint", "category": "arithmetic", "sql": "SELECT c_real // c_ubigint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_real // c_uhugeint AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_real // c_dec4_1 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_real // c_dec9_2 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_real // c_dec18_4 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_real // c_dec38_10 AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_real", "category": "arithmetic", "sql": "SELECT c_real // c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic: c_real // c_double", "category": "arithmetic", "sql": "SELECT c_real // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_tinyint", "category": "arithmetic", "sql": "SELECT c_double // c_tinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_smallint", "category": "arithmetic", "sql": "SELECT c_double // c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_integer", "category": "arithmetic", "sql": "SELECT c_double // c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_bigint", "category": "arithmetic", "sql": "SELECT c_double // c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_hugeint", "category": "arithmetic", "sql": "SELECT c_double // c_hugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_utinyint", "category": "arithmetic", "sql": "SELECT c_double // c_utinyint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_usmallint", "category": "arithmetic", "sql": "SELECT c_double // c_usmallint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_uinteger", "category": "arithmetic", "sql": "SELECT c_double // c_uinteger AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_ubigint", "category": "arithmetic", "sql": "SELECT c_double // c_ubigint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_uhugeint", "category": "arithmetic", "sql": "SELECT c_double // c_uhugeint AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_dec4_1", "category": "arithmetic", "sql": "SELECT c_double // c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_dec9_2", "category": "arithmetic", "sql": "SELECT c_double // c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_dec18_4", "category": "arithmetic", "sql": "SELECT c_double // c_dec18_4 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_dec38_10", "category": "arithmetic", "sql": "SELECT c_double // c_dec38_10 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_real", "category": "arithmetic", "sql": "SELECT c_double // c_real AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic: c_double // c_double", "category": "arithmetic", "sql": "SELECT c_double // c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 + 7", "category": "arithmetic_literal", "sql": "SELECT 7 + 7 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 7 + 2", "category": "arithmetic_literal", "sql": "SELECT 7 + 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 7 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 + 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 7 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 + 1.5 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 7 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 + 2.25 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 7 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 + 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 + 7", "category": "arithmetic_literal", "sql": "SELECT 2 + 7 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 2 + 2", "category": "arithmetic_literal", "sql": "SELECT 2 + 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 2 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 + 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 2 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 + 1.5 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 2 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 + 2.25 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 2 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 + 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 + 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 7 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 + 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 2 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 1.5 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic_literal: 3000000000 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 2.25 AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic_literal: 3000000000 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 + 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 7 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 1.5 + 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 2 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 1.5 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 3000000000 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic_literal: 1.5 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 1.5 AS v FROM t", "type": "DECIMAL(3,1)"}, + {"id": "arithmetic_literal: 1.5 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 2.25 AS v FROM t", "type": "DECIMAL(4,2)"}, + {"id": "arithmetic_literal: 1.5 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 + 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 7 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 2.25 + 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 2 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 2.25 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 3000000000 AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic_literal: 2.25 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 1.5 AS v FROM t", "type": "DECIMAL(4,2)"}, + {"id": "arithmetic_literal: 2.25 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 2.25 AS v FROM t", "type": "DECIMAL(4,2)"}, + {"id": "arithmetic_literal: 2.25 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 + 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 + 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 - 7", "category": "arithmetic_literal", "sql": "SELECT 7 - 7 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 7 - 2", "category": "arithmetic_literal", "sql": "SELECT 7 - 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 7 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 - 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 7 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 - 1.5 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 7 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 - 2.25 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 7 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 - 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 - 7", "category": "arithmetic_literal", "sql": "SELECT 2 - 7 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 2 - 2", "category": "arithmetic_literal", "sql": "SELECT 2 - 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 2 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 - 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 2 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 - 1.5 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 2 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 - 2.25 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 2 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 - 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 - 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 7 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 - 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 2 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 1.5 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic_literal: 3000000000 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 2.25 AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic_literal: 3000000000 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 - 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 7 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 1.5 - 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 2 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 1.5 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 3000000000 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic_literal: 1.5 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 1.5 AS v FROM t", "type": "DECIMAL(3,1)"}, + {"id": "arithmetic_literal: 1.5 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 2.25 AS v FROM t", "type": "DECIMAL(4,2)"}, + {"id": "arithmetic_literal: 1.5 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 - 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 7 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 2.25 - 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 2 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 2.25 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 3000000000 AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic_literal: 2.25 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 1.5 AS v FROM t", "type": "DECIMAL(4,2)"}, + {"id": "arithmetic_literal: 2.25 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 2.25 AS v FROM t", "type": "DECIMAL(4,2)"}, + {"id": "arithmetic_literal: 2.25 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 - 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 - 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 * 7", "category": "arithmetic_literal", "sql": "SELECT 7 * 7 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 7 * 2", "category": "arithmetic_literal", "sql": "SELECT 7 * 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 7 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 * 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 7 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 * 1.5 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 7 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 * 2.25 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 7 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 * 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 * 7", "category": "arithmetic_literal", "sql": "SELECT 2 * 7 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 2 * 2", "category": "arithmetic_literal", "sql": "SELECT 2 * 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 2 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 * 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 2 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 * 1.5 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 2 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 * 2.25 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 2 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 * 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 * 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 7 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 * 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 2 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 1.5 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic_literal: 3000000000 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 2.25 AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic_literal: 3000000000 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 * 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 7 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 1.5 * 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 2 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: 1.5 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 3000000000 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic_literal: 1.5 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 1.5 AS v FROM t", "type": "DECIMAL(4,2)"}, + {"id": "arithmetic_literal: 1.5 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 2.25 AS v FROM t", "type": "DECIMAL(5,3)"}, + {"id": "arithmetic_literal: 1.5 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 * 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 7 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 2.25 * 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 2 AS v FROM t", "type": "DECIMAL(13,2)"}, + {"id": "arithmetic_literal: 2.25 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 3000000000 AS v FROM t", "type": "DECIMAL(22,2)"}, + {"id": "arithmetic_literal: 2.25 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 1.5 AS v FROM t", "type": "DECIMAL(5,3)"}, + {"id": "arithmetic_literal: 2.25 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 2.25 AS v FROM t", "type": "DECIMAL(6,4)"}, + {"id": "arithmetic_literal: 2.25 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 * 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 * 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 / 7", "category": "arithmetic_literal", "sql": "SELECT 7 / 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 / 2", "category": "arithmetic_literal", "sql": "SELECT 7 / 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 / 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 / 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 / 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 / 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 / 7", "category": "arithmetic_literal", "sql": "SELECT 2 / 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 / 2", "category": "arithmetic_literal", "sql": "SELECT 2 / 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 / 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 / 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 / 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 / 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 / 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 / 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 / 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 / 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 / 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 / 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 / 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 / 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 % 7", "category": "arithmetic_literal", "sql": "SELECT 7 % 7 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 7 % 2", "category": "arithmetic_literal", "sql": "SELECT 7 % 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 7 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 % 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 7 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 % 1.5 AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "arithmetic_literal: 7 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 % 2.25 AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic_literal: 7 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 % 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 % 7", "category": "arithmetic_literal", "sql": "SELECT 2 % 7 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 2 % 2", "category": "arithmetic_literal", "sql": "SELECT 2 % 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 2 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 % 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 2 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 % 1.5 AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "arithmetic_literal: 2 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 % 2.25 AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic_literal: 2 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 % 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 % 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 7 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 % 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 2 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 1.5 AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "arithmetic_literal: 3000000000 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 2.25 AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "arithmetic_literal: 3000000000 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 % 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 7 AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "arithmetic_literal: 1.5 % 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 2 AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "arithmetic_literal: 1.5 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 3000000000 AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "arithmetic_literal: 1.5 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 1.5 AS v FROM t", "type": "DECIMAL(2,1)"}, + {"id": "arithmetic_literal: 1.5 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 2.25 AS v FROM t", "type": "DECIMAL(3,2)"}, + {"id": "arithmetic_literal: 1.5 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 % 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 7 AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic_literal: 2.25 % 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 2 AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "arithmetic_literal: 2.25 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 3000000000 AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "arithmetic_literal: 2.25 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 1.5 AS v FROM t", "type": "DECIMAL(3,2)"}, + {"id": "arithmetic_literal: 2.25 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 2.25 AS v FROM t", "type": "DECIMAL(3,2)"}, + {"id": "arithmetic_literal: 2.25 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 % 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 % 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 // 7", "category": "arithmetic_literal", "sql": "SELECT 7 // 7 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 7 // 2", "category": "arithmetic_literal", "sql": "SELECT 7 // 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 7 // 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 // 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 7 // 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 // 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 // 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 // 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 7 // 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 // 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 // 7", "category": "arithmetic_literal", "sql": "SELECT 2 // 7 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 2 // 2", "category": "arithmetic_literal", "sql": "SELECT 2 // 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: 2 // 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 // 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 2 // 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 // 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 // 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 // 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2 // 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 // 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 // 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 // 7 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 // 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 // 2 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 // 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 // 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: 3000000000 // 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 // 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 // 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 // 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 3000000000 // 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 // 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 // 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 // 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 // 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 // 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 // 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 // 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 // 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 // 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 // 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 // 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1.5 // 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 // 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 // 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 // 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 // 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 // 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 // 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 // 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 // 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 // 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 // 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 // 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 2.25 // 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 // 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 // 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 // 7 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 // 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 // 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 // 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 // 3000000000 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 // 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 // 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 // 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 // 2.25 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: 1e3 // 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 // 1e3 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_integer + 2", "category": "arithmetic_literal", "sql": "SELECT c_integer + 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: c_integer + 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer + 1.5 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: c_bigint + 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint + 2 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: c_bigint + 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint + 1.5 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic_literal: c_dec38_10 + 2", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 + 2 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic_literal: c_dec38_10 + 1.5", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 + 1.5 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic_literal: c_double + 2", "category": "arithmetic_literal", "sql": "SELECT c_double + 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_double + 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double + 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_integer - 2", "category": "arithmetic_literal", "sql": "SELECT c_integer - 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: c_integer - 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer - 1.5 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: c_bigint - 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint - 2 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: c_bigint - 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint - 1.5 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic_literal: c_dec38_10 - 2", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 - 2 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic_literal: c_dec38_10 - 1.5", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 - 1.5 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic_literal: c_double - 2", "category": "arithmetic_literal", "sql": "SELECT c_double - 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_double - 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double - 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_integer * 2", "category": "arithmetic_literal", "sql": "SELECT c_integer * 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: c_integer * 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer * 1.5 AS v FROM t", "type": "DECIMAL(12,1)"}, + {"id": "arithmetic_literal: c_bigint * 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint * 2 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: c_bigint * 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint * 1.5 AS v FROM t", "type": "DECIMAL(21,1)"}, + {"id": "arithmetic_literal: c_dec38_10 * 2", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 * 2 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic_literal: c_dec38_10 * 1.5", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 * 1.5 AS v FROM t", "type": "DECIMAL(38,11)"}, + {"id": "arithmetic_literal: c_double * 2", "category": "arithmetic_literal", "sql": "SELECT c_double * 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_double * 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double * 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_integer / 2", "category": "arithmetic_literal", "sql": "SELECT c_integer / 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_integer / 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer / 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_bigint / 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint / 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_bigint / 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint / 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_dec38_10 / 2", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 / 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_dec38_10 / 1.5", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 / 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_double / 2", "category": "arithmetic_literal", "sql": "SELECT c_double / 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_double / 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double / 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_integer % 2", "category": "arithmetic_literal", "sql": "SELECT c_integer % 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: c_integer % 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer % 1.5 AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "arithmetic_literal: c_bigint % 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint % 2 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: c_bigint % 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint % 1.5 AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "arithmetic_literal: c_dec38_10 % 2", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 % 2 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic_literal: c_dec38_10 % 1.5", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 % 1.5 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic_literal: c_double % 2", "category": "arithmetic_literal", "sql": "SELECT c_double % 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_double % 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double % 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_integer // 2", "category": "arithmetic_literal", "sql": "SELECT c_integer // 2 AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: c_integer // 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer // 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_bigint // 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint // 2 AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: c_bigint // 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint // 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_dec38_10 // 2", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 // 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_dec38_10 // 1.5", "category": "arithmetic_literal", "sql": "SELECT c_dec38_10 // 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_double // 2", "category": "arithmetic_literal", "sql": "SELECT c_double // 2 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: c_double // 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double // 1.5 AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: SUM(c_integer) / COUNT(*)", "category": "arithmetic_literal", "sql": "SELECT SUM(c_integer) / COUNT(*) AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: -c_integer", "category": "arithmetic_literal", "sql": "SELECT -c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: -c_double", "category": "arithmetic_literal", "sql": "SELECT -c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "arithmetic_literal: -c_tinyint", "category": "arithmetic_literal", "sql": "SELECT -c_tinyint AS v FROM t", "type": "TINYINT"}, + {"id": "arithmetic_literal: -c_smallint", "category": "arithmetic_literal", "sql": "SELECT -c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "arithmetic_literal: -c_integer", "category": "arithmetic_literal", "sql": "SELECT -c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "arithmetic_literal: -c_bigint", "category": "arithmetic_literal", "sql": "SELECT -c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "arithmetic_literal: -c_hugeint", "category": "arithmetic_literal", "sql": "SELECT -c_hugeint AS v FROM t", "type": "HUGEINT"}, + {"id": "arithmetic_literal: -c_utinyint", "category": "arithmetic_literal", "sql": "SELECT -c_utinyint AS v FROM t", "type": "UTINYINT"}, + {"id": "arithmetic_literal: -c_usmallint", "category": "arithmetic_literal", "sql": "SELECT -c_usmallint AS v FROM t", "type": "USMALLINT"}, + {"id": "arithmetic_literal: -c_uinteger", "category": "arithmetic_literal", "sql": "SELECT -c_uinteger AS v FROM t", "type": "UINTEGER"}, + {"id": "arithmetic_literal: -c_ubigint", "category": "arithmetic_literal", "sql": "SELECT -c_ubigint AS v FROM t", "type": "UBIGINT"}, + {"id": "arithmetic_literal: -c_uhugeint", "category": "arithmetic_literal", "sql": "SELECT -c_uhugeint AS v FROM t", "type": "UHUGEINT"}, + {"id": "arithmetic_literal: -c_dec4_1", "category": "arithmetic_literal", "sql": "SELECT -c_dec4_1 AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "arithmetic_literal: -c_dec9_2", "category": "arithmetic_literal", "sql": "SELECT -c_dec9_2 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "arithmetic_literal: -c_dec18_4", "category": "arithmetic_literal", "sql": "SELECT -c_dec18_4 AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "arithmetic_literal: -c_dec38_10", "category": "arithmetic_literal", "sql": "SELECT -c_dec38_10 AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "arithmetic_literal: -c_real", "category": "arithmetic_literal", "sql": "SELECT -c_real AS v FROM t", "type": "FLOAT"}, + {"id": "arithmetic_literal: -c_double", "category": "arithmetic_literal", "sql": "SELECT -c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "concat: c_varchar || c_varchar", "category": "concat", "sql": "SELECT c_varchar || c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "concat: c_varchar || c_integer", "category": "concat", "sql": "SELECT c_varchar || c_integer AS v FROM t", "type": "VARCHAR"}, + {"id": "concat: c_varchar || c_date", "category": "concat", "sql": "SELECT c_varchar || c_date AS v FROM t", "type": "VARCHAR"}, + {"id": "concat: 'a' || 'b'", "category": "concat", "sql": "SELECT 'a' || 'b' AS v FROM t", "type": "VARCHAR"}, + {"id": "concat: 'a' || c_varchar", "category": "concat", "sql": "SELECT 'a' || c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "concat: c_varchar || c_boolean", "category": "concat", "sql": "SELECT c_varchar || c_boolean AS v FROM t", "type": "VARCHAR"}, + {"id": "concat: c_varchar || c_double", "category": "concat", "sql": "SELECT c_varchar || c_double AS v FROM t", "type": "VARCHAR"}, + {"id": "concat: c_integer || c_integer", "category": "concat", "sql": "SELECT c_integer || c_integer AS v FROM t", "type": "VARCHAR"}, + {"id": "concat: CONCAT(c_varchar, c_integer)", "category": "concat", "sql": "SELECT CONCAT(c_varchar, c_integer) AS v FROM t", "type": "VARCHAR"}, + {"id": "concat: CONCAT(c_varchar, c_varchar)", "category": "concat", "sql": "SELECT CONCAT(c_varchar, c_varchar) AS v FROM t", "type": "VARCHAR"}, + {"id": "concat: CONCAT_WS(',', c_varchar, c_integer)", "category": "concat", "sql": "SELECT CONCAT_WS(',', c_varchar, c_integer) AS v FROM t", "type": "VARCHAR"}, + {"id": "comparison: c_integer = c_bigint", "category": "comparison", "sql": "SELECT c_integer = c_bigint AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_integer < c_double", "category": "comparison", "sql": "SELECT c_integer < c_double AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_varchar <> 'x'", "category": "comparison", "sql": "SELECT c_varchar <> 'x' AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_date >= c_timestamp", "category": "comparison", "sql": "SELECT c_date >= c_timestamp AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_boolean AND c_integer > 1", "category": "comparison", "sql": "SELECT c_boolean AND c_integer > 1 AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_boolean OR c_boolean", "category": "comparison", "sql": "SELECT c_boolean OR c_boolean AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: NOT c_boolean", "category": "comparison", "sql": "SELECT NOT c_boolean AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_integer IS NULL", "category": "comparison", "sql": "SELECT c_integer IS NULL AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_integer IS NOT NULL", "category": "comparison", "sql": "SELECT c_integer IS NOT NULL AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_integer BETWEEN 1 AND 3", "category": "comparison", "sql": "SELECT c_integer BETWEEN 1 AND 3 AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_integer IN (1, 2)", "category": "comparison", "sql": "SELECT c_integer IN (1, 2) AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_varchar LIKE 'a%'", "category": "comparison", "sql": "SELECT c_varchar LIKE 'a%' AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_varchar ILIKE 'a%'", "category": "comparison", "sql": "SELECT c_varchar ILIKE 'a%' AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_varchar NOT LIKE 'a%'", "category": "comparison", "sql": "SELECT c_varchar NOT LIKE 'a%' AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_boolean IS TRUE", "category": "comparison", "sql": "SELECT c_boolean IS TRUE AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: c_integer IS DISTINCT FROM c_bigint", "category": "comparison", "sql": "SELECT c_integer IS DISTINCT FROM c_bigint AS v FROM t", "type": "BOOLEAN"}, + {"id": "comparison: EXISTS (SELECT 1)", "category": "comparison", "sql": "SELECT EXISTS (SELECT 1) AS v FROM t", "type": "BOOLEAN"}, + {"id": "aggregate: SUM(c_tinyint)", "category": "aggregate", "sql": "SELECT SUM(c_tinyint) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: SUM(c_smallint)", "category": "aggregate", "sql": "SELECT SUM(c_smallint) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: SUM(c_integer)", "category": "aggregate", "sql": "SELECT SUM(c_integer) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: SUM(c_bigint)", "category": "aggregate", "sql": "SELECT SUM(c_bigint) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: SUM(c_hugeint)", "category": "aggregate", "sql": "SELECT SUM(c_hugeint) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: SUM(c_utinyint)", "category": "aggregate", "sql": "SELECT SUM(c_utinyint) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: SUM(c_usmallint)", "category": "aggregate", "sql": "SELECT SUM(c_usmallint) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: SUM(c_uinteger)", "category": "aggregate", "sql": "SELECT SUM(c_uinteger) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: SUM(c_ubigint)", "category": "aggregate", "sql": "SELECT SUM(c_ubigint) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: SUM(c_uhugeint)", "category": "aggregate", "sql": "SELECT SUM(c_uhugeint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: SUM(c_dec4_1)", "category": "aggregate", "sql": "SELECT SUM(c_dec4_1) AS v FROM t", "type": "DECIMAL(38,1)"}, + {"id": "aggregate: SUM(c_dec9_2)", "category": "aggregate", "sql": "SELECT SUM(c_dec9_2) AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "aggregate: SUM(c_dec18_4)", "category": "aggregate", "sql": "SELECT SUM(c_dec18_4) AS v FROM t", "type": "DECIMAL(38,4)"}, + {"id": "aggregate: SUM(c_dec38_10)", "category": "aggregate", "sql": "SELECT SUM(c_dec38_10) AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "aggregate: SUM(c_real)", "category": "aggregate", "sql": "SELECT SUM(c_real) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: SUM(c_double)", "category": "aggregate", "sql": "SELECT SUM(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: SUM(c_varchar)", "category": "aggregate", "sql": "SELECT SUM(c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: SUM(c_boolean)", "category": "aggregate", "sql": "SELECT SUM(c_boolean) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: SUM(c_date)", "category": "aggregate", "sql": "SELECT SUM(c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: SUM(c_timestamp)", "category": "aggregate", "sql": "SELECT SUM(c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: SUM(c_interval)", "category": "aggregate", "sql": "SELECT SUM(c_interval) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: AVG(c_tinyint)", "category": "aggregate", "sql": "SELECT AVG(c_tinyint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_smallint)", "category": "aggregate", "sql": "SELECT AVG(c_smallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_integer)", "category": "aggregate", "sql": "SELECT AVG(c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_bigint)", "category": "aggregate", "sql": "SELECT AVG(c_bigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_hugeint)", "category": "aggregate", "sql": "SELECT AVG(c_hugeint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_utinyint)", "category": "aggregate", "sql": "SELECT AVG(c_utinyint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_usmallint)", "category": "aggregate", "sql": "SELECT AVG(c_usmallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_uinteger)", "category": "aggregate", "sql": "SELECT AVG(c_uinteger) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_ubigint)", "category": "aggregate", "sql": "SELECT AVG(c_ubigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_uhugeint)", "category": "aggregate", "sql": "SELECT AVG(c_uhugeint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_dec4_1)", "category": "aggregate", "sql": "SELECT AVG(c_dec4_1) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_dec9_2)", "category": "aggregate", "sql": "SELECT AVG(c_dec9_2) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_dec18_4)", "category": "aggregate", "sql": "SELECT AVG(c_dec18_4) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_dec38_10)", "category": "aggregate", "sql": "SELECT AVG(c_dec38_10) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_real)", "category": "aggregate", "sql": "SELECT AVG(c_real) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_double)", "category": "aggregate", "sql": "SELECT AVG(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: AVG(c_varchar)", "category": "aggregate", "sql": "SELECT AVG(c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: AVG(c_boolean)", "category": "aggregate", "sql": "SELECT AVG(c_boolean) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: AVG(c_date)", "category": "aggregate", "sql": "SELECT AVG(c_date) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "aggregate: AVG(c_timestamp)", "category": "aggregate", "sql": "SELECT AVG(c_timestamp) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "aggregate: AVG(c_interval)", "category": "aggregate", "sql": "SELECT AVG(c_interval) AS v FROM t", "type": "INTERVAL"}, + {"id": "aggregate: MIN(c_tinyint)", "category": "aggregate", "sql": "SELECT MIN(c_tinyint) AS v FROM t", "type": "TINYINT"}, + {"id": "aggregate: MIN(c_smallint)", "category": "aggregate", "sql": "SELECT MIN(c_smallint) AS v FROM t", "type": "SMALLINT"}, + {"id": "aggregate: MIN(c_integer)", "category": "aggregate", "sql": "SELECT MIN(c_integer) AS v FROM t", "type": "INTEGER"}, + {"id": "aggregate: MIN(c_bigint)", "category": "aggregate", "sql": "SELECT MIN(c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: MIN(c_hugeint)", "category": "aggregate", "sql": "SELECT MIN(c_hugeint) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: MIN(c_utinyint)", "category": "aggregate", "sql": "SELECT MIN(c_utinyint) AS v FROM t", "type": "UTINYINT"}, + {"id": "aggregate: MIN(c_usmallint)", "category": "aggregate", "sql": "SELECT MIN(c_usmallint) AS v FROM t", "type": "USMALLINT"}, + {"id": "aggregate: MIN(c_uinteger)", "category": "aggregate", "sql": "SELECT MIN(c_uinteger) AS v FROM t", "type": "UINTEGER"}, + {"id": "aggregate: MIN(c_ubigint)", "category": "aggregate", "sql": "SELECT MIN(c_ubigint) AS v FROM t", "type": "UBIGINT"}, + {"id": "aggregate: MIN(c_uhugeint)", "category": "aggregate", "sql": "SELECT MIN(c_uhugeint) AS v FROM t", "type": "UHUGEINT"}, + {"id": "aggregate: MIN(c_dec4_1)", "category": "aggregate", "sql": "SELECT MIN(c_dec4_1) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "aggregate: MIN(c_dec9_2)", "category": "aggregate", "sql": "SELECT MIN(c_dec9_2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "aggregate: MIN(c_dec18_4)", "category": "aggregate", "sql": "SELECT MIN(c_dec18_4) AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "aggregate: MIN(c_dec38_10)", "category": "aggregate", "sql": "SELECT MIN(c_dec38_10) AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "aggregate: MIN(c_real)", "category": "aggregate", "sql": "SELECT MIN(c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "aggregate: MIN(c_double)", "category": "aggregate", "sql": "SELECT MIN(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: MIN(c_varchar)", "category": "aggregate", "sql": "SELECT MIN(c_varchar) AS v FROM t", "type": "VARCHAR"}, + {"id": "aggregate: MIN(c_boolean)", "category": "aggregate", "sql": "SELECT MIN(c_boolean) AS v FROM t", "type": "BOOLEAN"}, + {"id": "aggregate: MIN(c_date)", "category": "aggregate", "sql": "SELECT MIN(c_date) AS v FROM t", "type": "DATE"}, + {"id": "aggregate: MIN(c_timestamp)", "category": "aggregate", "sql": "SELECT MIN(c_timestamp) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "aggregate: MIN(c_interval)", "category": "aggregate", "sql": "SELECT MIN(c_interval) AS v FROM t", "type": "INTERVAL"}, + {"id": "aggregate: MAX(c_tinyint)", "category": "aggregate", "sql": "SELECT MAX(c_tinyint) AS v FROM t", "type": "TINYINT"}, + {"id": "aggregate: MAX(c_smallint)", "category": "aggregate", "sql": "SELECT MAX(c_smallint) AS v FROM t", "type": "SMALLINT"}, + {"id": "aggregate: MAX(c_integer)", "category": "aggregate", "sql": "SELECT MAX(c_integer) AS v FROM t", "type": "INTEGER"}, + {"id": "aggregate: MAX(c_bigint)", "category": "aggregate", "sql": "SELECT MAX(c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: MAX(c_hugeint)", "category": "aggregate", "sql": "SELECT MAX(c_hugeint) AS v FROM t", "type": "HUGEINT"}, + {"id": "aggregate: MAX(c_utinyint)", "category": "aggregate", "sql": "SELECT MAX(c_utinyint) AS v FROM t", "type": "UTINYINT"}, + {"id": "aggregate: MAX(c_usmallint)", "category": "aggregate", "sql": "SELECT MAX(c_usmallint) AS v FROM t", "type": "USMALLINT"}, + {"id": "aggregate: MAX(c_uinteger)", "category": "aggregate", "sql": "SELECT MAX(c_uinteger) AS v FROM t", "type": "UINTEGER"}, + {"id": "aggregate: MAX(c_ubigint)", "category": "aggregate", "sql": "SELECT MAX(c_ubigint) AS v FROM t", "type": "UBIGINT"}, + {"id": "aggregate: MAX(c_uhugeint)", "category": "aggregate", "sql": "SELECT MAX(c_uhugeint) AS v FROM t", "type": "UHUGEINT"}, + {"id": "aggregate: MAX(c_dec4_1)", "category": "aggregate", "sql": "SELECT MAX(c_dec4_1) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "aggregate: MAX(c_dec9_2)", "category": "aggregate", "sql": "SELECT MAX(c_dec9_2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "aggregate: MAX(c_dec18_4)", "category": "aggregate", "sql": "SELECT MAX(c_dec18_4) AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "aggregate: MAX(c_dec38_10)", "category": "aggregate", "sql": "SELECT MAX(c_dec38_10) AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "aggregate: MAX(c_real)", "category": "aggregate", "sql": "SELECT MAX(c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "aggregate: MAX(c_double)", "category": "aggregate", "sql": "SELECT MAX(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: MAX(c_varchar)", "category": "aggregate", "sql": "SELECT MAX(c_varchar) AS v FROM t", "type": "VARCHAR"}, + {"id": "aggregate: MAX(c_boolean)", "category": "aggregate", "sql": "SELECT MAX(c_boolean) AS v FROM t", "type": "BOOLEAN"}, + {"id": "aggregate: MAX(c_date)", "category": "aggregate", "sql": "SELECT MAX(c_date) AS v FROM t", "type": "DATE"}, + {"id": "aggregate: MAX(c_timestamp)", "category": "aggregate", "sql": "SELECT MAX(c_timestamp) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "aggregate: MAX(c_interval)", "category": "aggregate", "sql": "SELECT MAX(c_interval) AS v FROM t", "type": "INTERVAL"}, + {"id": "aggregate: COUNT(c_tinyint)", "category": "aggregate", "sql": "SELECT COUNT(c_tinyint) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_smallint)", "category": "aggregate", "sql": "SELECT COUNT(c_smallint) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_integer)", "category": "aggregate", "sql": "SELECT COUNT(c_integer) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_bigint)", "category": "aggregate", "sql": "SELECT COUNT(c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_hugeint)", "category": "aggregate", "sql": "SELECT COUNT(c_hugeint) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_utinyint)", "category": "aggregate", "sql": "SELECT COUNT(c_utinyint) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_usmallint)", "category": "aggregate", "sql": "SELECT COUNT(c_usmallint) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_uinteger)", "category": "aggregate", "sql": "SELECT COUNT(c_uinteger) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_ubigint)", "category": "aggregate", "sql": "SELECT COUNT(c_ubigint) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_uhugeint)", "category": "aggregate", "sql": "SELECT COUNT(c_uhugeint) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_dec4_1)", "category": "aggregate", "sql": "SELECT COUNT(c_dec4_1) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_dec9_2)", "category": "aggregate", "sql": "SELECT COUNT(c_dec9_2) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_dec18_4)", "category": "aggregate", "sql": "SELECT COUNT(c_dec18_4) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_dec38_10)", "category": "aggregate", "sql": "SELECT COUNT(c_dec38_10) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_real)", "category": "aggregate", "sql": "SELECT COUNT(c_real) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_double)", "category": "aggregate", "sql": "SELECT COUNT(c_double) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_varchar)", "category": "aggregate", "sql": "SELECT COUNT(c_varchar) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_boolean)", "category": "aggregate", "sql": "SELECT COUNT(c_boolean) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_date)", "category": "aggregate", "sql": "SELECT COUNT(c_date) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_timestamp)", "category": "aggregate", "sql": "SELECT COUNT(c_timestamp) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: COUNT(c_interval)", "category": "aggregate", "sql": "SELECT COUNT(c_interval) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: STDDEV(c_tinyint)", "category": "aggregate", "sql": "SELECT STDDEV(c_tinyint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_smallint)", "category": "aggregate", "sql": "SELECT STDDEV(c_smallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_integer)", "category": "aggregate", "sql": "SELECT STDDEV(c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_bigint)", "category": "aggregate", "sql": "SELECT STDDEV(c_bigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_hugeint)", "category": "aggregate", "sql": "SELECT STDDEV(c_hugeint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_utinyint)", "category": "aggregate", "sql": "SELECT STDDEV(c_utinyint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_usmallint)", "category": "aggregate", "sql": "SELECT STDDEV(c_usmallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_uinteger)", "category": "aggregate", "sql": "SELECT STDDEV(c_uinteger) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_ubigint)", "category": "aggregate", "sql": "SELECT STDDEV(c_ubigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_uhugeint)", "category": "aggregate", "sql": "SELECT STDDEV(c_uhugeint) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_dec4_1)", "category": "aggregate", "sql": "SELECT STDDEV(c_dec4_1) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_dec9_2)", "category": "aggregate", "sql": "SELECT STDDEV(c_dec9_2) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_dec18_4)", "category": "aggregate", "sql": "SELECT STDDEV(c_dec18_4) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_dec38_10)", "category": "aggregate", "sql": "SELECT STDDEV(c_dec38_10) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_real)", "category": "aggregate", "sql": "SELECT STDDEV(c_real) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_double)", "category": "aggregate", "sql": "SELECT STDDEV(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV(c_varchar)", "category": "aggregate", "sql": "SELECT STDDEV(c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: STDDEV(c_boolean)", "category": "aggregate", "sql": "SELECT STDDEV(c_boolean) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: STDDEV(c_date)", "category": "aggregate", "sql": "SELECT STDDEV(c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: STDDEV(c_timestamp)", "category": "aggregate", "sql": "SELECT STDDEV(c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: STDDEV(c_interval)", "category": "aggregate", "sql": "SELECT STDDEV(c_interval) AS v FROM t", "error": "Binder Error"}, + {"id": "aggregate: COUNT(*)", "category": "aggregate", "sql": "SELECT COUNT(*) AS v FROM t", "type": "BIGINT"}, + {"id": "aggregate: VARIANCE(c_integer)", "category": "aggregate", "sql": "SELECT VARIANCE(c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: VARIANCE(c_dec38_10)", "category": "aggregate", "sql": "SELECT VARIANCE(c_dec38_10) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: VARIANCE(c_double)", "category": "aggregate", "sql": "SELECT VARIANCE(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV_POP(c_integer)", "category": "aggregate", "sql": "SELECT STDDEV_POP(c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV_POP(c_dec38_10)", "category": "aggregate", "sql": "SELECT STDDEV_POP(c_dec38_10) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: STDDEV_POP(c_double)", "category": "aggregate", "sql": "SELECT STDDEV_POP(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: VAR_POP(c_integer)", "category": "aggregate", "sql": "SELECT VAR_POP(c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: VAR_POP(c_dec38_10)", "category": "aggregate", "sql": "SELECT VAR_POP(c_dec38_10) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: VAR_POP(c_double)", "category": "aggregate", "sql": "SELECT VAR_POP(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "aggregate: BOOL_AND(c_boolean)", "category": "aggregate", "sql": "SELECT BOOL_AND(c_boolean) AS v FROM t", "type": "BOOLEAN"}, + {"id": "aggregate: BOOL_OR(c_boolean)", "category": "aggregate", "sql": "SELECT BOOL_OR(c_boolean) AS v FROM t", "type": "BOOLEAN"}, + {"id": "aggregate: STRING_AGG(c_varchar, ',')", "category": "aggregate", "sql": "SELECT STRING_AGG(c_varchar, ',') AS v FROM t", "type": "VARCHAR"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_smallint END AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: COALESCE(c_smallint, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_smallint) AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: NULLIF(c_smallint, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_smallint) AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: IFNULL(c_smallint, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_smallint) AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_integer END AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: COALESCE(c_smallint, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_integer) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: NULLIF(c_smallint, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_integer) AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: IFNULL(c_smallint, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_integer) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_bigint END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_smallint, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_smallint, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_bigint) AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: IFNULL(c_smallint, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_bigint END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_smallint, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_smallint, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_bigint) AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: IFNULL(c_smallint, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_dec4_1 END AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "conditional: COALESCE(c_smallint, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_dec4_1) AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "conditional: NULLIF(c_smallint, c_dec4_1)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_dec4_1) AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: IFNULL(c_smallint, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_dec4_1) AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_dec9_2 END AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: COALESCE(c_smallint, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_dec9_2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: NULLIF(c_smallint, c_dec9_2)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_dec9_2) AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: IFNULL(c_smallint, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_dec9_2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_real END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_smallint, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_smallint, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_real) AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: IFNULL(c_smallint, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_double END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_smallint, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_smallint, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_double) AS v FROM t", "type": "SMALLINT"}, + {"id": "conditional: IFNULL(c_smallint, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_varchar END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_smallint, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_smallint, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_date END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_smallint, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_smallint, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_timestamp END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_smallint, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_smallint, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_smallint, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_smallint END AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: COALESCE(c_integer, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_smallint) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: NULLIF(c_integer, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_smallint) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: IFNULL(c_integer, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_smallint) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_integer END AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: COALESCE(c_integer, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_integer) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: NULLIF(c_integer, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_integer) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: IFNULL(c_integer, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_integer) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_bigint END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_integer, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_integer, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_bigint) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: IFNULL(c_integer, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_bigint END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_integer, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_integer, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_bigint) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: IFNULL(c_integer, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_dec4_1 END AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "conditional: COALESCE(c_integer, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_dec4_1) AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "conditional: NULLIF(c_integer, c_dec4_1)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_dec4_1) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: IFNULL(c_integer, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_dec4_1) AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_dec9_2 END AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "conditional: COALESCE(c_integer, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_dec9_2) AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "conditional: NULLIF(c_integer, c_dec9_2)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_dec9_2) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: IFNULL(c_integer, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_dec9_2) AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_real END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_integer, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_integer, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_real) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: IFNULL(c_integer, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_double END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_integer, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_integer, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_double) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: IFNULL(c_integer, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_varchar END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_integer, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_integer, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_date END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_integer, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_integer, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_timestamp END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_integer, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_integer, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_integer, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_smallint END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_bigint, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_smallint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_bigint, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_smallint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_smallint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_integer END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_bigint, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_integer) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_bigint, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_integer) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_integer) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_bigint END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_bigint END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_dec4_1 END AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: COALESCE(c_bigint, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_dec4_1) AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: NULLIF(c_bigint, c_dec4_1)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_dec4_1) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_dec4_1) AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_dec9_2 END AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: COALESCE(c_bigint, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_dec9_2) AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: NULLIF(c_bigint, c_dec9_2)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_dec9_2) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_dec9_2) AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_real END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_bigint, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_bigint, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_real) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_double END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_bigint, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_bigint, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_double) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_varchar END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_bigint, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_bigint, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_date END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_bigint, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_bigint, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_timestamp END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_bigint, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_bigint, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_smallint END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_bigint, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_smallint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_bigint, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_smallint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_smallint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_integer END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_bigint, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_integer) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_bigint, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_integer) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_integer) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_bigint END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_bigint END AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: COALESCE(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: NULLIF(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_dec4_1 END AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: COALESCE(c_bigint, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_dec4_1) AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: NULLIF(c_bigint, c_dec4_1)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_dec4_1) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_dec4_1) AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_dec9_2 END AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: COALESCE(c_bigint, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_dec9_2) AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: NULLIF(c_bigint, c_dec9_2)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_dec9_2) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_dec9_2) AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_real END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_bigint, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_bigint, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_real) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_double END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_bigint, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_bigint, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_double) AS v FROM t", "type": "BIGINT"}, + {"id": "conditional: IFNULL(c_bigint, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_varchar END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_bigint, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_bigint, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_date END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_bigint, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_bigint, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_timestamp END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_bigint, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_bigint, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_bigint, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_smallint END AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "conditional: COALESCE(c_dec4_1, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_smallint) AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "conditional: NULLIF(c_dec4_1, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_dec4_1, c_smallint) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: IFNULL(c_dec4_1, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_smallint) AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_integer END AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "conditional: COALESCE(c_dec4_1, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_integer) AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "conditional: NULLIF(c_dec4_1, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_dec4_1, c_integer) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: IFNULL(c_dec4_1, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_integer) AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_bigint END AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: COALESCE(c_dec4_1, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_bigint) AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: NULLIF(c_dec4_1, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_dec4_1, c_bigint) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: IFNULL(c_dec4_1, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_bigint) AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_bigint END AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: COALESCE(c_dec4_1, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_bigint) AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: NULLIF(c_dec4_1, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_dec4_1, c_bigint) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: IFNULL(c_dec4_1, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_bigint) AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_dec4_1 END AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: COALESCE(c_dec4_1, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_dec4_1) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: NULLIF(c_dec4_1, c_dec4_1)", "category": "conditional", "sql": "SELECT NULLIF(c_dec4_1, c_dec4_1) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: IFNULL(c_dec4_1, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_dec4_1) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_dec9_2 END AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: COALESCE(c_dec4_1, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_dec9_2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: NULLIF(c_dec4_1, c_dec9_2)", "category": "conditional", "sql": "SELECT NULLIF(c_dec4_1, c_dec9_2) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: IFNULL(c_dec4_1, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_dec9_2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_real END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_dec4_1, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_dec4_1, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_dec4_1, c_real) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: IFNULL(c_dec4_1, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_double END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_dec4_1, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_dec4_1, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_dec4_1, c_double) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "conditional: IFNULL(c_dec4_1, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_varchar END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_dec4_1, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_dec4_1, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_date END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_dec4_1, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_dec4_1, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec4_1 ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec4_1 ELSE c_timestamp END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_dec4_1, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_dec4_1, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_dec4_1, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_dec4_1, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_smallint END AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: COALESCE(c_dec9_2, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_smallint) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: NULLIF(c_dec9_2, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_dec9_2, c_smallint) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: IFNULL(c_dec9_2, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_smallint) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_integer END AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "conditional: COALESCE(c_dec9_2, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_integer) AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "conditional: NULLIF(c_dec9_2, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_dec9_2, c_integer) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: IFNULL(c_dec9_2, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_integer) AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_bigint END AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: COALESCE(c_dec9_2, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_bigint) AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: NULLIF(c_dec9_2, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_dec9_2, c_bigint) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: IFNULL(c_dec9_2, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_bigint) AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_bigint END AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: COALESCE(c_dec9_2, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_bigint) AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: NULLIF(c_dec9_2, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_dec9_2, c_bigint) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: IFNULL(c_dec9_2, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_bigint) AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_dec4_1 END AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: COALESCE(c_dec9_2, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_dec4_1) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: NULLIF(c_dec9_2, c_dec4_1)", "category": "conditional", "sql": "SELECT NULLIF(c_dec9_2, c_dec4_1) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: IFNULL(c_dec9_2, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_dec4_1) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_dec9_2 END AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: COALESCE(c_dec9_2, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_dec9_2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: NULLIF(c_dec9_2, c_dec9_2)", "category": "conditional", "sql": "SELECT NULLIF(c_dec9_2, c_dec9_2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: IFNULL(c_dec9_2, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_dec9_2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_real END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_dec9_2, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_dec9_2, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_dec9_2, c_real) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: IFNULL(c_dec9_2, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_double END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_dec9_2, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_dec9_2, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_dec9_2, c_double) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "conditional: IFNULL(c_dec9_2, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_varchar END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_dec9_2, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_dec9_2, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_date END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_dec9_2, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_dec9_2, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_dec9_2 ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_dec9_2 ELSE c_timestamp END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_dec9_2, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_dec9_2, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_dec9_2, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_dec9_2, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_smallint END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_real, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_smallint) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_real, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_smallint) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: IFNULL(c_real, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_smallint) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_integer END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_real, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_integer) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_real, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_integer) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: IFNULL(c_real, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_integer) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_bigint END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_real, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_bigint) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_real, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_bigint) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: IFNULL(c_real, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_bigint) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_bigint END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_real, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_bigint) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_real, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_bigint) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: IFNULL(c_real, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_bigint) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_dec4_1 END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_real, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_dec4_1) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_real, c_dec4_1)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_dec4_1) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: IFNULL(c_real, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_dec4_1) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_dec9_2 END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_real, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_dec9_2) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_real, c_dec9_2)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_dec9_2) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: IFNULL(c_real, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_dec9_2) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_real END AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: COALESCE(c_real, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: NULLIF(c_real, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: IFNULL(c_real, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_double END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_real, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_real, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_double) AS v FROM t", "type": "FLOAT"}, + {"id": "conditional: IFNULL(c_real, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_varchar END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_real, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_real, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_date END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_real, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_real, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_timestamp END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_real, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_real, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_real, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_smallint END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_double, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_smallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_double, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_smallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: IFNULL(c_double, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_smallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_integer END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_double, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_double, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: IFNULL(c_double, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_bigint END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_double, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_bigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_double, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_bigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: IFNULL(c_double, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_bigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_bigint END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_double, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_bigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_double, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_bigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: IFNULL(c_double, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_bigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_dec4_1 END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_double, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_dec4_1) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_double, c_dec4_1)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_dec4_1) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: IFNULL(c_double, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_dec4_1) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_dec9_2 END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_double, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_dec9_2) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_double, c_dec9_2)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_dec9_2) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: IFNULL(c_double, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_dec9_2) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_real END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_double, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_real) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_double, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_real) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: IFNULL(c_double, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_real) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_double END AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: COALESCE(c_double, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: NULLIF(c_double, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: IFNULL(c_double, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_varchar END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_double, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_double, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_date END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_double, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_double, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_timestamp END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_double, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_double, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_double, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_smallint END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_varchar, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_smallint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_varchar, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_smallint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_integer END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_varchar, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_integer) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_varchar, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_integer) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_bigint END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_varchar, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_varchar, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_bigint END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_varchar, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_varchar, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_dec4_1 END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_varchar, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_dec4_1) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_varchar, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_dec4_1) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_dec9_2 END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_varchar, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_dec9_2) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_varchar, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_dec9_2) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_real END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_varchar, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_real) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_varchar, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_real) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_double END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_varchar, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_double) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_varchar, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_double) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_varchar END AS v FROM t", "type": "VARCHAR"}, + {"id": "conditional: COALESCE(c_varchar, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_varchar) AS v FROM t", "type": "VARCHAR"}, + {"id": "conditional: NULLIF(c_varchar, c_varchar)", "category": "conditional", "sql": "SELECT NULLIF(c_varchar, c_varchar) AS v FROM t", "type": "VARCHAR"}, + {"id": "conditional: IFNULL(c_varchar, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_varchar) AS v FROM t", "type": "VARCHAR"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_date END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_varchar, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_varchar, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_date) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_varchar ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_varchar ELSE c_timestamp END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_varchar, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_varchar, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_varchar, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_varchar, c_timestamp) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_smallint END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_date, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_smallint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_date, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_smallint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_integer END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_date, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_integer) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_date, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_integer) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_bigint END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_date, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_date, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_bigint END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_date, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_date, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_dec4_1 END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_date, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_dec4_1) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_date, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_dec4_1) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_dec9_2 END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_date, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_dec9_2) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_date, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_dec9_2) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_real END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_date, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_real) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_date, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_real) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_double END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_date, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_double) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_date, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_double) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_varchar END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_date, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_date, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_date END AS v FROM t", "type": "DATE"}, + {"id": "conditional: COALESCE(c_date, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_date) AS v FROM t", "type": "DATE"}, + {"id": "conditional: NULLIF(c_date, c_date)", "category": "conditional", "sql": "SELECT NULLIF(c_date, c_date) AS v FROM t", "type": "DATE"}, + {"id": "conditional: IFNULL(c_date, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_date) AS v FROM t", "type": "DATE"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_timestamp END AS v FROM t", "type": "TIMESTAMP"}, + {"id": "conditional: COALESCE(c_date, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_timestamp) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "conditional: IFNULL(c_date, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_date, c_timestamp) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_smallint END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_timestamp, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_smallint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_timestamp, c_smallint)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_smallint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_integer END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_timestamp, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_integer) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_timestamp, c_integer)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_integer) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_bigint END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_timestamp, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_timestamp, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_bigint END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_timestamp, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_timestamp, c_bigint)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_bigint) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_dec4_1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_dec4_1 END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_timestamp, c_dec4_1)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_dec4_1) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_timestamp, c_dec4_1)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_dec4_1) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_dec9_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_dec9_2 END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_timestamp, c_dec9_2)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_dec9_2) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_timestamp, c_dec9_2)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_dec9_2) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_real END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_timestamp, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_real) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_timestamp, c_real)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_real) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_double END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_timestamp, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_double) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_timestamp, c_double)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_double) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_varchar END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_varchar END AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: COALESCE(c_timestamp, c_varchar)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: IFNULL(c_timestamp, c_varchar)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_varchar) AS v FROM t", "error": "Binder Error"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_date END AS v FROM t", "type": "TIMESTAMP"}, + {"id": "conditional: COALESCE(c_timestamp, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_date) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "conditional: IFNULL(c_timestamp, c_date)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_date) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_timestamp END AS v FROM t", "type": "TIMESTAMP"}, + {"id": "conditional: COALESCE(c_timestamp, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_timestamp) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "conditional: NULLIF(c_timestamp, c_timestamp)", "category": "conditional", "sql": "SELECT NULLIF(c_timestamp, c_timestamp) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "conditional: IFNULL(c_timestamp, c_timestamp)", "category": "conditional", "sql": "SELECT IFNULL(c_timestamp, c_timestamp) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "conditional: COALESCE(c_integer, 1)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, 1) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE 1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE 1 END AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: COALESCE(c_integer, 1.5)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, 1.5) AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE 1.5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE 1.5 END AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "conditional: COALESCE(c_integer, 'x')", "category": "conditional", "sql": "SELECT COALESCE(c_integer, 'x') AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE 'x' END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE 'x' END AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: COALESCE(c_integer, NULL)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, NULL) AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE NULL END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE NULL END AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: CASE WHEN c_boolean THEN 1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN 1 END AS v FROM t", "type": "INTEGER"}, + {"id": "conditional: CASE WHEN c_boolean THEN 1 ELSE 2.5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN 1 ELSE 2.5 END AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "set_operation: c_smallint UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "SMALLINT"}, + {"id": "set_operation: c_smallint UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "set_operation: c_smallint UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_smallint UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_smallint UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "set_operation: c_smallint UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "set_operation: c_smallint UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_smallint UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_smallint UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_smallint UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_smallint UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_integer UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "INTEGER"}, + {"id": "set_operation: c_integer UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "set_operation: c_integer UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_integer UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_integer UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "set_operation: c_integer UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "set_operation: c_integer UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_integer UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_integer UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_integer UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_integer UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_bigint UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_bigint UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_bigint UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_bigint UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_bigint UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "set_operation: c_bigint UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "set_operation: c_bigint UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_bigint UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_bigint UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_bigint UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_bigint UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_bigint UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_bigint UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_bigint UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_bigint UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: c_bigint UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "set_operation: c_bigint UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "set_operation: c_bigint UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_bigint UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_bigint UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_bigint UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_bigint UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "DECIMAL(6,1)"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "DECIMAL(20,1)"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_dec4_1 UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_dec4_1 AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "DECIMAL(12,2)"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "DECIMAL(21,2)"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_dec9_2 UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_dec9_2 AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_real UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_real UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_real UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_real UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_real UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_real UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_real UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "FLOAT"}, + {"id": "set_operation: c_real UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_real UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_real UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_real UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_double UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_double UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_double UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_double UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_double UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_double UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_double UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_double UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "DOUBLE"}, + {"id": "set_operation: c_double UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_double UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_double UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_varchar UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_varchar UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_varchar UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_varchar UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_varchar UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_varchar UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_varchar UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_varchar UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_varchar UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_varchar UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_date AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_varchar UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_varchar AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_date UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_date UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_date UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_date UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_date UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_date UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_date UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_real AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_date UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_double AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_date UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_date UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_date AS v FROM t", "type": "DATE"}, + {"id": "set_operation: c_date UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "type": "TIMESTAMP"}, + {"id": "set_operation: c_timestamp UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_timestamp UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_timestamp UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_timestamp UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_timestamp UNION ALL c_dec4_1", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_dec4_1 AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_timestamp UNION ALL c_dec9_2", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_dec9_2 AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_timestamp UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_real AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_timestamp UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_double AS v FROM t", "error": "Conversion Error"}, + {"id": "set_operation: c_timestamp UNION ALL c_varchar", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_varchar AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: c_timestamp UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_date AS v FROM t", "type": "TIMESTAMP"}, + {"id": "set_operation: c_timestamp UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "type": "TIMESTAMP"}, + {"id": "set_operation: 1 UNION ALL 2.5", "category": "set_operation", "sql": "SELECT 1 AS v FROM t UNION ALL SELECT 2.5 AS v FROM t", "type": "DECIMAL(11,1)"}, + {"id": "set_operation: 1 UNION ALL 3000000000", "category": "set_operation", "sql": "SELECT 1 AS v FROM t UNION ALL SELECT 3000000000 AS v FROM t", "type": "BIGINT"}, + {"id": "set_operation: 'a' UNION ALL 'bc'", "category": "set_operation", "sql": "SELECT 'a' AS v FROM t UNION ALL SELECT 'bc' AS v FROM t", "type": "VARCHAR"}, + {"id": "set_operation: NULL UNION ALL c_integer", "category": "set_operation", "sql": "SELECT NULL AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "INTEGER"}, + {"id": "datetime: c_date + 1", "category": "datetime", "sql": "SELECT c_date + 1 AS v FROM t", "type": "DATE"}, + {"id": "datetime: 1 + c_date", "category": "datetime", "sql": "SELECT 1 + c_date AS v FROM t", "type": "DATE"}, + {"id": "datetime: c_date - 1", "category": "datetime", "sql": "SELECT c_date - 1 AS v FROM t", "type": "DATE"}, + {"id": "datetime: c_date - c_date", "category": "datetime", "sql": "SELECT c_date - c_date AS v FROM t", "type": "BIGINT"}, + {"id": "datetime: c_date + INTERVAL 1 DAY", "category": "datetime", "sql": "SELECT c_date + INTERVAL 1 DAY AS v FROM t", "type": "TIMESTAMP"}, + {"id": "datetime: c_date - INTERVAL 1 DAY", "category": "datetime", "sql": "SELECT c_date - INTERVAL 1 DAY AS v FROM t", "type": "TIMESTAMP"}, + {"id": "datetime: c_timestamp + INTERVAL 1 DAY", "category": "datetime", "sql": "SELECT c_timestamp + INTERVAL 1 DAY AS v FROM t", "type": "TIMESTAMP"}, + {"id": "datetime: c_timestamp - INTERVAL 1 DAY", "category": "datetime", "sql": "SELECT c_timestamp - INTERVAL 1 DAY AS v FROM t", "type": "TIMESTAMP"}, + {"id": "datetime: c_timestamptz + INTERVAL 1 DAY", "category": "datetime", "sql": "SELECT c_timestamptz + INTERVAL 1 DAY AS v FROM t", "type": "TIMESTAMP WITH TIME ZONE"}, + {"id": "datetime: c_timestamp - c_timestamp", "category": "datetime", "sql": "SELECT c_timestamp - c_timestamp AS v FROM t", "type": "INTERVAL"}, + {"id": "datetime: c_timestamptz - c_timestamptz", "category": "datetime", "sql": "SELECT c_timestamptz - c_timestamptz AS v FROM t", "type": "INTERVAL"}, + {"id": "datetime: c_date - c_timestamp", "category": "datetime", "sql": "SELECT c_date - c_timestamp AS v FROM t", "type": "INTERVAL"}, + {"id": "datetime: c_time + INTERVAL 1 DAY", "category": "datetime", "sql": "SELECT c_time + INTERVAL 1 DAY AS v FROM t", "type": "TIME"}, + {"id": "datetime: c_time - c_time", "category": "datetime", "sql": "SELECT c_time - c_time AS v FROM t", "error": "Binder Error"}, + {"id": "datetime: c_date + c_time", "category": "datetime", "sql": "SELECT c_date + c_time AS v FROM t", "type": "TIMESTAMP"}, + {"id": "datetime: c_interval + c_interval", "category": "datetime", "sql": "SELECT c_interval + c_interval AS v FROM t", "type": "INTERVAL"}, + {"id": "datetime: c_interval * 2", "category": "datetime", "sql": "SELECT c_interval * 2 AS v FROM t", "type": "INTERVAL"}, + {"id": "datetime: c_interval / 2", "category": "datetime", "sql": "SELECT c_interval / 2 AS v FROM t", "type": "INTERVAL"}, + {"id": "datetime: -c_interval", "category": "datetime", "sql": "SELECT -c_interval AS v FROM t", "type": "INTERVAL"}, + {"id": "datetime: INTERVAL 1 DAY", "category": "datetime", "sql": "SELECT INTERVAL 1 DAY AS v FROM t", "type": "INTERVAL"}, + {"id": "datetime: c_timestamp - c_date", "category": "datetime", "sql": "SELECT c_timestamp - c_date AS v FROM t", "type": "INTERVAL"}, + {"id": "cast: CAST('1' AS TINYINT)", "category": "cast", "sql": "SELECT CAST('1' AS TINYINT) AS v FROM t", "type": "TINYINT"}, + {"id": "cast: CAST('1' AS SMALLINT)", "category": "cast", "sql": "SELECT CAST('1' AS SMALLINT) AS v FROM t", "type": "SMALLINT"}, + {"id": "cast: CAST('1' AS INTEGER)", "category": "cast", "sql": "SELECT CAST('1' AS INTEGER) AS v FROM t", "type": "INTEGER"}, + {"id": "cast: CAST('1' AS BIGINT)", "category": "cast", "sql": "SELECT CAST('1' AS BIGINT) AS v FROM t", "type": "BIGINT"}, + {"id": "cast: CAST('1' AS HUGEINT)", "category": "cast", "sql": "SELECT CAST('1' AS HUGEINT) AS v FROM t", "type": "HUGEINT"}, + {"id": "cast: CAST('1' AS UBIGINT)", "category": "cast", "sql": "SELECT CAST('1' AS UBIGINT) AS v FROM t", "type": "UBIGINT"}, + {"id": "cast: CAST('1' AS DECIMAL)", "category": "cast", "sql": "SELECT CAST('1' AS DECIMAL) AS v FROM t", "type": "DECIMAL(18,3)"}, + {"id": "cast: CAST('1' AS DECIMAL(10,2))", "category": "cast", "sql": "SELECT CAST('1' AS DECIMAL(10,2)) AS v FROM t", "type": "DECIMAL(10,2)"}, + {"id": "cast: CAST('1' AS DECIMAL(5))", "category": "cast", "sql": "SELECT CAST('1' AS DECIMAL(5)) AS v FROM t", "type": "DECIMAL(5,0)"}, + {"id": "cast: CAST('1' AS NUMERIC(12,4))", "category": "cast", "sql": "SELECT CAST('1' AS NUMERIC(12,4)) AS v FROM t", "type": "DECIMAL(12,4)"}, + {"id": "cast: CAST('1' AS REAL)", "category": "cast", "sql": "SELECT CAST('1' AS REAL) AS v FROM t", "type": "FLOAT"}, + {"id": "cast: CAST('1' AS FLOAT)", "category": "cast", "sql": "SELECT CAST('1' AS FLOAT) AS v FROM t", "type": "FLOAT"}, + {"id": "cast: CAST('1' AS DOUBLE)", "category": "cast", "sql": "SELECT CAST('1' AS DOUBLE) AS v FROM t", "type": "DOUBLE"}, + {"id": "cast: CAST('1' AS VARCHAR)", "category": "cast", "sql": "SELECT CAST('1' AS VARCHAR) AS v FROM t", "type": "VARCHAR"}, + {"id": "cast: CAST('1' AS VARCHAR(10))", "category": "cast", "sql": "SELECT CAST('1' AS VARCHAR(10)) AS v FROM t", "type": "VARCHAR"}, + {"id": "cast: CAST('1' AS TEXT)", "category": "cast", "sql": "SELECT CAST('1' AS TEXT) AS v FROM t", "type": "VARCHAR"}, + {"id": "cast: CAST('true' AS BOOLEAN)", "category": "cast", "sql": "SELECT CAST('true' AS BOOLEAN) AS v FROM t", "type": "BOOLEAN"}, + {"id": "cast: CAST('2026-01-02' AS DATE)", "category": "cast", "sql": "SELECT CAST('2026-01-02' AS DATE) AS v FROM t", "type": "DATE"}, + {"id": "cast: CAST('2026-01-02' AS TIMESTAMP)", "category": "cast", "sql": "SELECT CAST('2026-01-02' AS TIMESTAMP) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "cast: CAST('2026-01-02' AS TIMESTAMPTZ)", "category": "cast", "sql": "SELECT CAST('2026-01-02' AS TIMESTAMPTZ) AS v FROM t", "type": "TIMESTAMP WITH TIME ZONE"}, + {"id": "cast: CAST('03:04:05' AS TIME)", "category": "cast", "sql": "SELECT CAST('03:04:05' AS TIME) AS v FROM t", "type": "TIME"}, + {"id": "cast: CAST('1 day' AS INTERVAL)", "category": "cast", "sql": "SELECT CAST('1 day' AS INTERVAL) AS v FROM t", "type": "INTERVAL"}, + {"id": "cast: CAST('abc' AS BLOB)", "category": "cast", "sql": "SELECT CAST('abc' AS BLOB) AS v FROM t", "type": "BLOB"}, + {"id": "cast: CAST('00000000-0000-0000-0000-000000000000' AS UUID)", "category": "cast", "sql": "SELECT CAST('00000000-0000-0000-0000-000000000000' AS UUID) AS v FROM t", "type": "UUID"}, + {"id": "cast: CAST('{}' AS JSON)", "category": "cast", "sql": "SELECT CAST('{}' AS JSON) AS v FROM t", "type": "JSON"}, + {"id": "cast: c_integer::BIGINT", "category": "cast", "sql": "SELECT c_integer::BIGINT AS v FROM t", "type": "BIGINT"}, + {"id": "cast: CAST(c_integer AS VARCHAR)", "category": "cast", "sql": "SELECT CAST(c_integer AS VARCHAR) AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: ROUND(c_tinyint)", "category": "scalar", "sql": "SELECT ROUND(c_tinyint) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: ROUND(c_smallint)", "category": "scalar", "sql": "SELECT ROUND(c_smallint) AS v FROM t", "type": "SMALLINT"}, + {"id": "scalar: ROUND(c_integer)", "category": "scalar", "sql": "SELECT ROUND(c_integer) AS v FROM t", "type": "INTEGER"}, + {"id": "scalar: ROUND(c_bigint)", "category": "scalar", "sql": "SELECT ROUND(c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: ROUND(c_hugeint)", "category": "scalar", "sql": "SELECT ROUND(c_hugeint) AS v FROM t", "type": "HUGEINT"}, + {"id": "scalar: ROUND(c_utinyint)", "category": "scalar", "sql": "SELECT ROUND(c_utinyint) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: ROUND(c_usmallint)", "category": "scalar", "sql": "SELECT ROUND(c_usmallint) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: ROUND(c_uinteger)", "category": "scalar", "sql": "SELECT ROUND(c_uinteger) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: ROUND(c_ubigint)", "category": "scalar", "sql": "SELECT ROUND(c_ubigint) AS v FROM t", "type": "HUGEINT"}, + {"id": "scalar: ROUND(c_uhugeint)", "category": "scalar", "sql": "SELECT ROUND(c_uhugeint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: ROUND(c_dec4_1)", "category": "scalar", "sql": "SELECT ROUND(c_dec4_1) AS v FROM t", "type": "DECIMAL(4,0)"}, + {"id": "scalar: ROUND(c_dec9_2)", "category": "scalar", "sql": "SELECT ROUND(c_dec9_2) AS v FROM t", "type": "DECIMAL(9,0)"}, + {"id": "scalar: ROUND(c_dec18_4)", "category": "scalar", "sql": "SELECT ROUND(c_dec18_4) AS v FROM t", "type": "DECIMAL(18,0)"}, + {"id": "scalar: ROUND(c_dec38_10)", "category": "scalar", "sql": "SELECT ROUND(c_dec38_10) AS v FROM t", "type": "DECIMAL(38,0)"}, + {"id": "scalar: ROUND(c_real)", "category": "scalar", "sql": "SELECT ROUND(c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "scalar: ROUND(c_double)", "category": "scalar", "sql": "SELECT ROUND(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: ABS(c_tinyint)", "category": "scalar", "sql": "SELECT ABS(c_tinyint) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: ABS(c_smallint)", "category": "scalar", "sql": "SELECT ABS(c_smallint) AS v FROM t", "type": "SMALLINT"}, + {"id": "scalar: ABS(c_integer)", "category": "scalar", "sql": "SELECT ABS(c_integer) AS v FROM t", "type": "INTEGER"}, + {"id": "scalar: ABS(c_bigint)", "category": "scalar", "sql": "SELECT ABS(c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: ABS(c_hugeint)", "category": "scalar", "sql": "SELECT ABS(c_hugeint) AS v FROM t", "type": "HUGEINT"}, + {"id": "scalar: ABS(c_utinyint)", "category": "scalar", "sql": "SELECT ABS(c_utinyint) AS v FROM t", "type": "UTINYINT"}, + {"id": "scalar: ABS(c_usmallint)", "category": "scalar", "sql": "SELECT ABS(c_usmallint) AS v FROM t", "type": "USMALLINT"}, + {"id": "scalar: ABS(c_uinteger)", "category": "scalar", "sql": "SELECT ABS(c_uinteger) AS v FROM t", "type": "UINTEGER"}, + {"id": "scalar: ABS(c_ubigint)", "category": "scalar", "sql": "SELECT ABS(c_ubigint) AS v FROM t", "type": "UBIGINT"}, + {"id": "scalar: ABS(c_uhugeint)", "category": "scalar", "sql": "SELECT ABS(c_uhugeint) AS v FROM t", "type": "UHUGEINT"}, + {"id": "scalar: ABS(c_dec4_1)", "category": "scalar", "sql": "SELECT ABS(c_dec4_1) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "scalar: ABS(c_dec9_2)", "category": "scalar", "sql": "SELECT ABS(c_dec9_2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "scalar: ABS(c_dec18_4)", "category": "scalar", "sql": "SELECT ABS(c_dec18_4) AS v FROM t", "type": "DECIMAL(18,4)"}, + {"id": "scalar: ABS(c_dec38_10)", "category": "scalar", "sql": "SELECT ABS(c_dec38_10) AS v FROM t", "type": "DECIMAL(38,10)"}, + {"id": "scalar: ABS(c_real)", "category": "scalar", "sql": "SELECT ABS(c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "scalar: ABS(c_double)", "category": "scalar", "sql": "SELECT ABS(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_tinyint)", "category": "scalar", "sql": "SELECT FLOOR(c_tinyint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_smallint)", "category": "scalar", "sql": "SELECT FLOOR(c_smallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_integer)", "category": "scalar", "sql": "SELECT FLOOR(c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_bigint)", "category": "scalar", "sql": "SELECT FLOOR(c_bigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_hugeint)", "category": "scalar", "sql": "SELECT FLOOR(c_hugeint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_utinyint)", "category": "scalar", "sql": "SELECT FLOOR(c_utinyint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_usmallint)", "category": "scalar", "sql": "SELECT FLOOR(c_usmallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_uinteger)", "category": "scalar", "sql": "SELECT FLOOR(c_uinteger) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_ubigint)", "category": "scalar", "sql": "SELECT FLOOR(c_ubigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_uhugeint)", "category": "scalar", "sql": "SELECT FLOOR(c_uhugeint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: FLOOR(c_dec4_1)", "category": "scalar", "sql": "SELECT FLOOR(c_dec4_1) AS v FROM t", "type": "DECIMAL(4,0)"}, + {"id": "scalar: FLOOR(c_dec9_2)", "category": "scalar", "sql": "SELECT FLOOR(c_dec9_2) AS v FROM t", "type": "DECIMAL(9,0)"}, + {"id": "scalar: FLOOR(c_dec18_4)", "category": "scalar", "sql": "SELECT FLOOR(c_dec18_4) AS v FROM t", "type": "DECIMAL(18,0)"}, + {"id": "scalar: FLOOR(c_dec38_10)", "category": "scalar", "sql": "SELECT FLOOR(c_dec38_10) AS v FROM t", "type": "DECIMAL(38,0)"}, + {"id": "scalar: FLOOR(c_real)", "category": "scalar", "sql": "SELECT FLOOR(c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "scalar: FLOOR(c_double)", "category": "scalar", "sql": "SELECT FLOOR(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_tinyint)", "category": "scalar", "sql": "SELECT CEIL(c_tinyint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_smallint)", "category": "scalar", "sql": "SELECT CEIL(c_smallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_integer)", "category": "scalar", "sql": "SELECT CEIL(c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_bigint)", "category": "scalar", "sql": "SELECT CEIL(c_bigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_hugeint)", "category": "scalar", "sql": "SELECT CEIL(c_hugeint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_utinyint)", "category": "scalar", "sql": "SELECT CEIL(c_utinyint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_usmallint)", "category": "scalar", "sql": "SELECT CEIL(c_usmallint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_uinteger)", "category": "scalar", "sql": "SELECT CEIL(c_uinteger) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_ubigint)", "category": "scalar", "sql": "SELECT CEIL(c_ubigint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_uhugeint)", "category": "scalar", "sql": "SELECT CEIL(c_uhugeint) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: CEIL(c_dec4_1)", "category": "scalar", "sql": "SELECT CEIL(c_dec4_1) AS v FROM t", "type": "DECIMAL(4,0)"}, + {"id": "scalar: CEIL(c_dec9_2)", "category": "scalar", "sql": "SELECT CEIL(c_dec9_2) AS v FROM t", "type": "DECIMAL(9,0)"}, + {"id": "scalar: CEIL(c_dec18_4)", "category": "scalar", "sql": "SELECT CEIL(c_dec18_4) AS v FROM t", "type": "DECIMAL(18,0)"}, + {"id": "scalar: CEIL(c_dec38_10)", "category": "scalar", "sql": "SELECT CEIL(c_dec38_10) AS v FROM t", "type": "DECIMAL(38,0)"}, + {"id": "scalar: CEIL(c_real)", "category": "scalar", "sql": "SELECT CEIL(c_real) AS v FROM t", "type": "FLOAT"}, + {"id": "scalar: CEIL(c_double)", "category": "scalar", "sql": "SELECT CEIL(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: SIGN(c_tinyint)", "category": "scalar", "sql": "SELECT SIGN(c_tinyint) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_smallint)", "category": "scalar", "sql": "SELECT SIGN(c_smallint) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_integer)", "category": "scalar", "sql": "SELECT SIGN(c_integer) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_bigint)", "category": "scalar", "sql": "SELECT SIGN(c_bigint) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_hugeint)", "category": "scalar", "sql": "SELECT SIGN(c_hugeint) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_utinyint)", "category": "scalar", "sql": "SELECT SIGN(c_utinyint) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_usmallint)", "category": "scalar", "sql": "SELECT SIGN(c_usmallint) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_uinteger)", "category": "scalar", "sql": "SELECT SIGN(c_uinteger) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_ubigint)", "category": "scalar", "sql": "SELECT SIGN(c_ubigint) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_uhugeint)", "category": "scalar", "sql": "SELECT SIGN(c_uhugeint) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_dec4_1)", "category": "scalar", "sql": "SELECT SIGN(c_dec4_1) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_dec9_2)", "category": "scalar", "sql": "SELECT SIGN(c_dec9_2) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_dec18_4)", "category": "scalar", "sql": "SELECT SIGN(c_dec18_4) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_dec38_10)", "category": "scalar", "sql": "SELECT SIGN(c_dec38_10) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_real)", "category": "scalar", "sql": "SELECT SIGN(c_real) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: SIGN(c_double)", "category": "scalar", "sql": "SELECT SIGN(c_double) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: ROUND(c_tinyint, 2)", "category": "scalar", "sql": "SELECT ROUND(c_tinyint, 2) AS v FROM t", "type": "TINYINT"}, + {"id": "scalar: ROUND(c_smallint, 2)", "category": "scalar", "sql": "SELECT ROUND(c_smallint, 2) AS v FROM t", "type": "SMALLINT"}, + {"id": "scalar: ROUND(c_integer, 2)", "category": "scalar", "sql": "SELECT ROUND(c_integer, 2) AS v FROM t", "type": "INTEGER"}, + {"id": "scalar: ROUND(c_bigint, 2)", "category": "scalar", "sql": "SELECT ROUND(c_bigint, 2) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: ROUND(c_hugeint, 2)", "category": "scalar", "sql": "SELECT ROUND(c_hugeint, 2) AS v FROM t", "type": "HUGEINT"}, + {"id": "scalar: ROUND(c_utinyint, 2)", "category": "scalar", "sql": "SELECT ROUND(c_utinyint, 2) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: ROUND(c_usmallint, 2)", "category": "scalar", "sql": "SELECT ROUND(c_usmallint, 2) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: ROUND(c_uinteger, 2)", "category": "scalar", "sql": "SELECT ROUND(c_uinteger, 2) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: ROUND(c_ubigint, 2)", "category": "scalar", "sql": "SELECT ROUND(c_ubigint, 2) AS v FROM t", "type": "HUGEINT"}, + {"id": "scalar: ROUND(c_uhugeint, 2)", "category": "scalar", "sql": "SELECT ROUND(c_uhugeint, 2) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: ROUND(c_dec4_1, 2)", "category": "scalar", "sql": "SELECT ROUND(c_dec4_1, 2) AS v FROM t", "type": "DECIMAL(4,1)"}, + {"id": "scalar: ROUND(c_dec9_2, 2)", "category": "scalar", "sql": "SELECT ROUND(c_dec9_2, 2) AS v FROM t", "type": "DECIMAL(9,2)"}, + {"id": "scalar: ROUND(c_dec18_4, 2)", "category": "scalar", "sql": "SELECT ROUND(c_dec18_4, 2) AS v FROM t", "type": "DECIMAL(18,2)"}, + {"id": "scalar: ROUND(c_dec38_10, 2)", "category": "scalar", "sql": "SELECT ROUND(c_dec38_10, 2) AS v FROM t", "type": "DECIMAL(38,2)"}, + {"id": "scalar: ROUND(c_real, 2)", "category": "scalar", "sql": "SELECT ROUND(c_real, 2) AS v FROM t", "type": "FLOAT"}, + {"id": "scalar: ROUND(c_double, 2)", "category": "scalar", "sql": "SELECT ROUND(c_double, 2) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: LENGTH(c_varchar)", "category": "scalar", "sql": "SELECT LENGTH(c_varchar) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: CHAR_LENGTH(c_varchar)", "category": "scalar", "sql": "SELECT CHAR_LENGTH(c_varchar) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: SUBSTRING(c_varchar, 1, 2)", "category": "scalar", "sql": "SELECT SUBSTRING(c_varchar, 1, 2) AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: SUBSTR(c_varchar, 1, 2)", "category": "scalar", "sql": "SELECT SUBSTR(c_varchar, 1, 2) AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: UPPER(c_varchar)", "category": "scalar", "sql": "SELECT UPPER(c_varchar) AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: LOWER(c_varchar)", "category": "scalar", "sql": "SELECT LOWER(c_varchar) AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: TRIM(c_varchar)", "category": "scalar", "sql": "SELECT TRIM(c_varchar) AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: REPLACE(c_varchar, 'a', 'b')", "category": "scalar", "sql": "SELECT REPLACE(c_varchar, 'a', 'b') AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: LEFT(c_varchar, 2)", "category": "scalar", "sql": "SELECT LEFT(c_varchar, 2) AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: POSITION('a' IN c_varchar)", "category": "scalar", "sql": "SELECT POSITION('a' IN c_varchar) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: DATE_TRUNC('month', c_date)", "category": "scalar", "sql": "SELECT DATE_TRUNC('month', c_date) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "scalar: DATE_TRUNC('month', c_timestamp)", "category": "scalar", "sql": "SELECT DATE_TRUNC('month', c_timestamp) AS v FROM t", "type": "TIMESTAMP"}, + {"id": "scalar: DATE_TRUNC('month', c_timestamptz)", "category": "scalar", "sql": "SELECT DATE_TRUNC('month', c_timestamptz) AS v FROM t", "type": "TIMESTAMP WITH TIME ZONE"}, + {"id": "scalar: EXTRACT(YEAR FROM c_date)", "category": "scalar", "sql": "SELECT EXTRACT(YEAR FROM c_date) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: EXTRACT(YEAR FROM c_timestamp)", "category": "scalar", "sql": "SELECT EXTRACT(YEAR FROM c_timestamp) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: EXTRACT(EPOCH FROM c_timestamp)", "category": "scalar", "sql": "SELECT EXTRACT(EPOCH FROM c_timestamp) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: EXTRACT(DOW FROM c_date)", "category": "scalar", "sql": "SELECT EXTRACT(DOW FROM c_date) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: DATE_PART('year', c_date)", "category": "scalar", "sql": "SELECT DATE_PART('year', c_date) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: NOW()", "category": "scalar", "sql": "SELECT NOW() AS v FROM t", "type": "TIMESTAMP WITH TIME ZONE"}, + {"id": "scalar: SQRT(c_double)", "category": "scalar", "sql": "SELECT SQRT(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: POWER(c_integer, 2)", "category": "scalar", "sql": "SELECT POWER(c_integer, 2) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: LN(c_double)", "category": "scalar", "sql": "SELECT LN(c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: EXP(c_integer)", "category": "scalar", "sql": "SELECT EXP(c_integer) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: MOD(c_integer, 2)", "category": "scalar", "sql": "SELECT MOD(c_integer, 2) AS v FROM t", "type": "INTEGER"}, + {"id": "scalar: GREATEST(c_integer, c_bigint)", "category": "scalar", "sql": "SELECT GREATEST(c_integer, c_bigint) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: LEAST(c_integer, c_double)", "category": "scalar", "sql": "SELECT LEAST(c_integer, c_double) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: RANDOM()", "category": "scalar", "sql": "SELECT RANDOM() AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: MD5(c_varchar)", "category": "scalar", "sql": "SELECT MD5(c_varchar) AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: ROW_NUMBER() OVER (ORDER BY c_integer)", "category": "scalar", "sql": "SELECT ROW_NUMBER() OVER (ORDER BY c_integer) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: RANK() OVER (ORDER BY c_integer)", "category": "scalar", "sql": "SELECT RANK() OVER (ORDER BY c_integer) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: LAG(c_integer) OVER (ORDER BY c_integer)", "category": "scalar", "sql": "SELECT LAG(c_integer) OVER (ORDER BY c_integer) AS v FROM t", "type": "INTEGER"}, + {"id": "scalar: SUM(c_integer) OVER ()", "category": "scalar", "sql": "SELECT SUM(c_integer) OVER () AS v FROM t", "type": "HUGEINT"}, + {"id": "scalar: COUNT(*) OVER ()", "category": "scalar", "sql": "SELECT COUNT(*) OVER () AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: TODAY()", "category": "scalar", "sql": "SELECT TODAY() AS v FROM t", "type": "DATE"}, + {"id": "scalar: CURRENT_DATABASE()", "category": "scalar", "sql": "SELECT CURRENT_DATABASE() AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: GEN_RANDOM_UUID()", "category": "scalar", "sql": "SELECT GEN_RANDOM_UUID() AS v FROM t", "type": "UUID"}, + {"id": "scalar: EPOCH(c_timestamp)", "category": "scalar", "sql": "SELECT EPOCH(c_timestamp) AS v FROM t", "type": "DOUBLE"}, + {"id": "scalar: YEAR(c_date)", "category": "scalar", "sql": "SELECT YEAR(c_date) AS v FROM t", "type": "BIGINT"}, + {"id": "scalar: DAYNAME(c_date)", "category": "scalar", "sql": "SELECT DAYNAME(c_date) AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: STRFTIME(c_date, '%Y')", "category": "scalar", "sql": "SELECT STRFTIME(c_date, '%Y') AS v FROM t", "type": "VARCHAR"}, + {"id": "scalar: LIST_VALUE(1, 2)", "category": "scalar", "sql": "SELECT LIST_VALUE(1, 2) AS v FROM t", "type": "INTEGER[]"}, + {"id": "niladic: USER", "category": "niladic", "sql": "SELECT USER AS v FROM t", "type": "VARCHAR"}, + {"id": "niladic: USER without FROM", "category": "niladic", "sql": "SELECT USER AS v", "type": "VARCHAR"}, + {"id": "niladic: USER in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE USER IS NOT NULL", "type": "INTEGER"}, + {"id": "niladic: CURRENT_USER", "category": "niladic", "sql": "SELECT CURRENT_USER AS v FROM t", "type": "VARCHAR"}, + {"id": "niladic: CURRENT_USER without FROM", "category": "niladic", "sql": "SELECT CURRENT_USER AS v", "type": "VARCHAR"}, + {"id": "niladic: CURRENT_USER in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_USER IS NOT NULL", "type": "INTEGER"}, + {"id": "niladic: SESSION_USER", "category": "niladic", "sql": "SELECT SESSION_USER AS v FROM t", "type": "VARCHAR"}, + {"id": "niladic: SESSION_USER without FROM", "category": "niladic", "sql": "SELECT SESSION_USER AS v", "type": "VARCHAR"}, + {"id": "niladic: SESSION_USER in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE SESSION_USER IS NOT NULL", "type": "INTEGER"}, + {"id": "niladic: CURRENT_ROLE", "category": "niladic", "sql": "SELECT CURRENT_ROLE AS v FROM t", "type": "VARCHAR"}, + {"id": "niladic: CURRENT_ROLE without FROM", "category": "niladic", "sql": "SELECT CURRENT_ROLE AS v", "type": "VARCHAR"}, + {"id": "niladic: CURRENT_ROLE in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_ROLE IS NOT NULL", "type": "INTEGER"}, + {"id": "niladic: CURRENT_SCHEMA", "category": "niladic", "sql": "SELECT CURRENT_SCHEMA AS v FROM t", "type": "VARCHAR"}, + {"id": "niladic: CURRENT_SCHEMA without FROM", "category": "niladic", "sql": "SELECT CURRENT_SCHEMA AS v", "type": "VARCHAR"}, + {"id": "niladic: CURRENT_SCHEMA in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_SCHEMA IS NOT NULL", "type": "INTEGER"}, + {"id": "niladic: CURRENT_CATALOG", "category": "niladic", "sql": "SELECT CURRENT_CATALOG AS v FROM t", "type": "VARCHAR"}, + {"id": "niladic: CURRENT_CATALOG without FROM", "category": "niladic", "sql": "SELECT CURRENT_CATALOG AS v", "type": "VARCHAR"}, + {"id": "niladic: CURRENT_CATALOG in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_CATALOG IS NOT NULL", "type": "INTEGER"}, + {"id": "niladic: CURRENT_DATE", "category": "niladic", "sql": "SELECT CURRENT_DATE AS v FROM t", "type": "DATE"}, + {"id": "niladic: CURRENT_DATE without FROM", "category": "niladic", "sql": "SELECT CURRENT_DATE AS v", "type": "DATE"}, + {"id": "niladic: CURRENT_DATE in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_DATE IS NOT NULL", "type": "INTEGER"}, + {"id": "niladic: CURRENT_TIME", "category": "niladic", "sql": "SELECT CURRENT_TIME AS v FROM t", "type": "TIME WITH TIME ZONE"}, + {"id": "niladic: CURRENT_TIME without FROM", "category": "niladic", "sql": "SELECT CURRENT_TIME AS v", "type": "TIME WITH TIME ZONE"}, + {"id": "niladic: CURRENT_TIME in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_TIME IS NOT NULL", "type": "INTEGER"}, + {"id": "niladic: CURRENT_TIMESTAMP", "category": "niladic", "sql": "SELECT CURRENT_TIMESTAMP AS v FROM t", "type": "TIMESTAMP WITH TIME ZONE"}, + {"id": "niladic: CURRENT_TIMESTAMP without FROM", "category": "niladic", "sql": "SELECT CURRENT_TIMESTAMP AS v", "type": "TIMESTAMP WITH TIME ZONE"}, + {"id": "niladic: CURRENT_TIMESTAMP in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_TIMESTAMP IS NOT NULL", "type": "INTEGER"}, + {"id": "niladic: LOCALTIME", "category": "niladic", "sql": "SELECT LOCALTIME AS v FROM t", "type": "TIME"}, + {"id": "niladic: LOCALTIME without FROM", "category": "niladic", "sql": "SELECT LOCALTIME AS v", "type": "TIME"}, + {"id": "niladic: LOCALTIME in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE LOCALTIME IS NOT NULL", "type": "INTEGER"}, + {"id": "niladic: LOCALTIMESTAMP", "category": "niladic", "sql": "SELECT LOCALTIMESTAMP AS v FROM t", "type": "TIMESTAMP"}, + {"id": "niladic: LOCALTIMESTAMP without FROM", "category": "niladic", "sql": "SELECT LOCALTIMESTAMP AS v", "type": "TIMESTAMP"}, + {"id": "niladic: LOCALTIMESTAMP in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE LOCALTIMESTAMP IS NOT NULL", "type": "INTEGER"} + ] +} diff --git a/crates/polyglot-sql/tests/fixtures/engine_types/postgres.json b/crates/polyglot-sql/tests/fixtures/engine_types/postgres.json new file mode 100644 index 00000000..9062172c --- /dev/null +++ b/crates/polyglot-sql/tests/fixtures/engine_types/postgres.json @@ -0,0 +1,1362 @@ +{ + "engine": "postgres", + "engine_version": "17.5 (Debian 17.5-1.pgdg120+1)", + "method": "temporary view column type over one-row synthetic table t, cross-checked with pg_typeof()", + "schema": { + "tables": [ + { + "name": "t", + "columns": [ + { + "name": "c_smallint", + "type": "smallint" + }, + { + "name": "c_integer", + "type": "integer" + }, + { + "name": "c_bigint", + "type": "bigint" + }, + { + "name": "c_num10_2", + "type": "numeric(10,2)" + }, + { + "name": "c_num20_5", + "type": "numeric(20,5)" + }, + { + "name": "c_numeric", + "type": "numeric" + }, + { + "name": "c_real", + "type": "real" + }, + { + "name": "c_double", + "type": "double precision" + }, + { + "name": "c_text", + "type": "text" + }, + { + "name": "c_varchar", + "type": "varchar(20)" + }, + { + "name": "c_boolean", + "type": "boolean" + }, + { + "name": "c_date", + "type": "date" + }, + { + "name": "c_timestamp", + "type": "timestamp" + }, + { + "name": "c_timestamptz", + "type": "timestamptz" + }, + { + "name": "c_time", + "type": "time" + }, + { + "name": "c_interval", + "type": "interval" + } + ] + } + ] + }, + "cases": [ + {"id": "arithmetic: c_smallint + c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint + c_smallint AS v FROM t", "type": "smallint"}, + {"id": "arithmetic: c_smallint + c_integer", "category": "arithmetic", "sql": "SELECT c_smallint + c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_smallint + c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint + c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_smallint + c_num10_2", "category": "arithmetic", "sql": "SELECT c_smallint + c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint + c_num20_5", "category": "arithmetic", "sql": "SELECT c_smallint + c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint + c_numeric", "category": "arithmetic", "sql": "SELECT c_smallint + c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint + c_real", "category": "arithmetic", "sql": "SELECT c_smallint + c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_smallint + c_double", "category": "arithmetic", "sql": "SELECT c_smallint + c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_integer + c_smallint", "category": "arithmetic", "sql": "SELECT c_integer + c_smallint AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_integer + c_integer", "category": "arithmetic", "sql": "SELECT c_integer + c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_integer + c_bigint", "category": "arithmetic", "sql": "SELECT c_integer + c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_integer + c_num10_2", "category": "arithmetic", "sql": "SELECT c_integer + c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer + c_num20_5", "category": "arithmetic", "sql": "SELECT c_integer + c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer + c_numeric", "category": "arithmetic", "sql": "SELECT c_integer + c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer + c_real", "category": "arithmetic", "sql": "SELECT c_integer + c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_integer + c_double", "category": "arithmetic", "sql": "SELECT c_integer + c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_bigint + c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint + c_smallint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint + c_integer", "category": "arithmetic", "sql": "SELECT c_bigint + c_integer AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint + c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint + c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint + c_num10_2", "category": "arithmetic", "sql": "SELECT c_bigint + c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint + c_num20_5", "category": "arithmetic", "sql": "SELECT c_bigint + c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint + c_numeric", "category": "arithmetic", "sql": "SELECT c_bigint + c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint + c_real", "category": "arithmetic", "sql": "SELECT c_bigint + c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_bigint + c_double", "category": "arithmetic", "sql": "SELECT c_bigint + c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num10_2 + c_smallint", "category": "arithmetic", "sql": "SELECT c_num10_2 + c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 + c_integer", "category": "arithmetic", "sql": "SELECT c_num10_2 + c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 + c_bigint", "category": "arithmetic", "sql": "SELECT c_num10_2 + c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 + c_num10_2", "category": "arithmetic", "sql": "SELECT c_num10_2 + c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 + c_num20_5", "category": "arithmetic", "sql": "SELECT c_num10_2 + c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 + c_numeric", "category": "arithmetic", "sql": "SELECT c_num10_2 + c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 + c_real", "category": "arithmetic", "sql": "SELECT c_num10_2 + c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num10_2 + c_double", "category": "arithmetic", "sql": "SELECT c_num10_2 + c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num20_5 + c_smallint", "category": "arithmetic", "sql": "SELECT c_num20_5 + c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 + c_integer", "category": "arithmetic", "sql": "SELECT c_num20_5 + c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 + c_bigint", "category": "arithmetic", "sql": "SELECT c_num20_5 + c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 + c_num10_2", "category": "arithmetic", "sql": "SELECT c_num20_5 + c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 + c_num20_5", "category": "arithmetic", "sql": "SELECT c_num20_5 + c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 + c_numeric", "category": "arithmetic", "sql": "SELECT c_num20_5 + c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 + c_real", "category": "arithmetic", "sql": "SELECT c_num20_5 + c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num20_5 + c_double", "category": "arithmetic", "sql": "SELECT c_num20_5 + c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_numeric + c_smallint", "category": "arithmetic", "sql": "SELECT c_numeric + c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric + c_integer", "category": "arithmetic", "sql": "SELECT c_numeric + c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric + c_bigint", "category": "arithmetic", "sql": "SELECT c_numeric + c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric + c_num10_2", "category": "arithmetic", "sql": "SELECT c_numeric + c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric + c_num20_5", "category": "arithmetic", "sql": "SELECT c_numeric + c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric + c_numeric", "category": "arithmetic", "sql": "SELECT c_numeric + c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric + c_real", "category": "arithmetic", "sql": "SELECT c_numeric + c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_numeric + c_double", "category": "arithmetic", "sql": "SELECT c_numeric + c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real + c_smallint", "category": "arithmetic", "sql": "SELECT c_real + c_smallint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real + c_integer", "category": "arithmetic", "sql": "SELECT c_real + c_integer AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real + c_bigint", "category": "arithmetic", "sql": "SELECT c_real + c_bigint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real + c_num10_2", "category": "arithmetic", "sql": "SELECT c_real + c_num10_2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real + c_num20_5", "category": "arithmetic", "sql": "SELECT c_real + c_num20_5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real + c_numeric", "category": "arithmetic", "sql": "SELECT c_real + c_numeric AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real + c_real", "category": "arithmetic", "sql": "SELECT c_real + c_real AS v FROM t", "type": "real"}, + {"id": "arithmetic: c_real + c_double", "category": "arithmetic", "sql": "SELECT c_real + c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double + c_smallint", "category": "arithmetic", "sql": "SELECT c_double + c_smallint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double + c_integer", "category": "arithmetic", "sql": "SELECT c_double + c_integer AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double + c_bigint", "category": "arithmetic", "sql": "SELECT c_double + c_bigint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double + c_num10_2", "category": "arithmetic", "sql": "SELECT c_double + c_num10_2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double + c_num20_5", "category": "arithmetic", "sql": "SELECT c_double + c_num20_5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double + c_numeric", "category": "arithmetic", "sql": "SELECT c_double + c_numeric AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double + c_real", "category": "arithmetic", "sql": "SELECT c_double + c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double + c_double", "category": "arithmetic", "sql": "SELECT c_double + c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_smallint - c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint - c_smallint AS v FROM t", "type": "smallint"}, + {"id": "arithmetic: c_smallint - c_integer", "category": "arithmetic", "sql": "SELECT c_smallint - c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_smallint - c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint - c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_smallint - c_num10_2", "category": "arithmetic", "sql": "SELECT c_smallint - c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint - c_num20_5", "category": "arithmetic", "sql": "SELECT c_smallint - c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint - c_numeric", "category": "arithmetic", "sql": "SELECT c_smallint - c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint - c_real", "category": "arithmetic", "sql": "SELECT c_smallint - c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_smallint - c_double", "category": "arithmetic", "sql": "SELECT c_smallint - c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_integer - c_smallint", "category": "arithmetic", "sql": "SELECT c_integer - c_smallint AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_integer - c_integer", "category": "arithmetic", "sql": "SELECT c_integer - c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_integer - c_bigint", "category": "arithmetic", "sql": "SELECT c_integer - c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_integer - c_num10_2", "category": "arithmetic", "sql": "SELECT c_integer - c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer - c_num20_5", "category": "arithmetic", "sql": "SELECT c_integer - c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer - c_numeric", "category": "arithmetic", "sql": "SELECT c_integer - c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer - c_real", "category": "arithmetic", "sql": "SELECT c_integer - c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_integer - c_double", "category": "arithmetic", "sql": "SELECT c_integer - c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_bigint - c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint - c_smallint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint - c_integer", "category": "arithmetic", "sql": "SELECT c_bigint - c_integer AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint - c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint - c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint - c_num10_2", "category": "arithmetic", "sql": "SELECT c_bigint - c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint - c_num20_5", "category": "arithmetic", "sql": "SELECT c_bigint - c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint - c_numeric", "category": "arithmetic", "sql": "SELECT c_bigint - c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint - c_real", "category": "arithmetic", "sql": "SELECT c_bigint - c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_bigint - c_double", "category": "arithmetic", "sql": "SELECT c_bigint - c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num10_2 - c_smallint", "category": "arithmetic", "sql": "SELECT c_num10_2 - c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 - c_integer", "category": "arithmetic", "sql": "SELECT c_num10_2 - c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 - c_bigint", "category": "arithmetic", "sql": "SELECT c_num10_2 - c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 - c_num10_2", "category": "arithmetic", "sql": "SELECT c_num10_2 - c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 - c_num20_5", "category": "arithmetic", "sql": "SELECT c_num10_2 - c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 - c_numeric", "category": "arithmetic", "sql": "SELECT c_num10_2 - c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 - c_real", "category": "arithmetic", "sql": "SELECT c_num10_2 - c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num10_2 - c_double", "category": "arithmetic", "sql": "SELECT c_num10_2 - c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num20_5 - c_smallint", "category": "arithmetic", "sql": "SELECT c_num20_5 - c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 - c_integer", "category": "arithmetic", "sql": "SELECT c_num20_5 - c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 - c_bigint", "category": "arithmetic", "sql": "SELECT c_num20_5 - c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 - c_num10_2", "category": "arithmetic", "sql": "SELECT c_num20_5 - c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 - c_num20_5", "category": "arithmetic", "sql": "SELECT c_num20_5 - c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 - c_numeric", "category": "arithmetic", "sql": "SELECT c_num20_5 - c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 - c_real", "category": "arithmetic", "sql": "SELECT c_num20_5 - c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num20_5 - c_double", "category": "arithmetic", "sql": "SELECT c_num20_5 - c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_numeric - c_smallint", "category": "arithmetic", "sql": "SELECT c_numeric - c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric - c_integer", "category": "arithmetic", "sql": "SELECT c_numeric - c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric - c_bigint", "category": "arithmetic", "sql": "SELECT c_numeric - c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric - c_num10_2", "category": "arithmetic", "sql": "SELECT c_numeric - c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric - c_num20_5", "category": "arithmetic", "sql": "SELECT c_numeric - c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric - c_numeric", "category": "arithmetic", "sql": "SELECT c_numeric - c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric - c_real", "category": "arithmetic", "sql": "SELECT c_numeric - c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_numeric - c_double", "category": "arithmetic", "sql": "SELECT c_numeric - c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real - c_smallint", "category": "arithmetic", "sql": "SELECT c_real - c_smallint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real - c_integer", "category": "arithmetic", "sql": "SELECT c_real - c_integer AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real - c_bigint", "category": "arithmetic", "sql": "SELECT c_real - c_bigint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real - c_num10_2", "category": "arithmetic", "sql": "SELECT c_real - c_num10_2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real - c_num20_5", "category": "arithmetic", "sql": "SELECT c_real - c_num20_5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real - c_numeric", "category": "arithmetic", "sql": "SELECT c_real - c_numeric AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real - c_real", "category": "arithmetic", "sql": "SELECT c_real - c_real AS v FROM t", "type": "real"}, + {"id": "arithmetic: c_real - c_double", "category": "arithmetic", "sql": "SELECT c_real - c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double - c_smallint", "category": "arithmetic", "sql": "SELECT c_double - c_smallint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double - c_integer", "category": "arithmetic", "sql": "SELECT c_double - c_integer AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double - c_bigint", "category": "arithmetic", "sql": "SELECT c_double - c_bigint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double - c_num10_2", "category": "arithmetic", "sql": "SELECT c_double - c_num10_2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double - c_num20_5", "category": "arithmetic", "sql": "SELECT c_double - c_num20_5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double - c_numeric", "category": "arithmetic", "sql": "SELECT c_double - c_numeric AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double - c_real", "category": "arithmetic", "sql": "SELECT c_double - c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double - c_double", "category": "arithmetic", "sql": "SELECT c_double - c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_smallint * c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint * c_smallint AS v FROM t", "type": "smallint"}, + {"id": "arithmetic: c_smallint * c_integer", "category": "arithmetic", "sql": "SELECT c_smallint * c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_smallint * c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint * c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_smallint * c_num10_2", "category": "arithmetic", "sql": "SELECT c_smallint * c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint * c_num20_5", "category": "arithmetic", "sql": "SELECT c_smallint * c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint * c_numeric", "category": "arithmetic", "sql": "SELECT c_smallint * c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint * c_real", "category": "arithmetic", "sql": "SELECT c_smallint * c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_smallint * c_double", "category": "arithmetic", "sql": "SELECT c_smallint * c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_integer * c_smallint", "category": "arithmetic", "sql": "SELECT c_integer * c_smallint AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_integer * c_integer", "category": "arithmetic", "sql": "SELECT c_integer * c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_integer * c_bigint", "category": "arithmetic", "sql": "SELECT c_integer * c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_integer * c_num10_2", "category": "arithmetic", "sql": "SELECT c_integer * c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer * c_num20_5", "category": "arithmetic", "sql": "SELECT c_integer * c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer * c_numeric", "category": "arithmetic", "sql": "SELECT c_integer * c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer * c_real", "category": "arithmetic", "sql": "SELECT c_integer * c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_integer * c_double", "category": "arithmetic", "sql": "SELECT c_integer * c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_bigint * c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint * c_smallint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint * c_integer", "category": "arithmetic", "sql": "SELECT c_bigint * c_integer AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint * c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint * c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint * c_num10_2", "category": "arithmetic", "sql": "SELECT c_bigint * c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint * c_num20_5", "category": "arithmetic", "sql": "SELECT c_bigint * c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint * c_numeric", "category": "arithmetic", "sql": "SELECT c_bigint * c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint * c_real", "category": "arithmetic", "sql": "SELECT c_bigint * c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_bigint * c_double", "category": "arithmetic", "sql": "SELECT c_bigint * c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num10_2 * c_smallint", "category": "arithmetic", "sql": "SELECT c_num10_2 * c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 * c_integer", "category": "arithmetic", "sql": "SELECT c_num10_2 * c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 * c_bigint", "category": "arithmetic", "sql": "SELECT c_num10_2 * c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 * c_num10_2", "category": "arithmetic", "sql": "SELECT c_num10_2 * c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 * c_num20_5", "category": "arithmetic", "sql": "SELECT c_num10_2 * c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 * c_numeric", "category": "arithmetic", "sql": "SELECT c_num10_2 * c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 * c_real", "category": "arithmetic", "sql": "SELECT c_num10_2 * c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num10_2 * c_double", "category": "arithmetic", "sql": "SELECT c_num10_2 * c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num20_5 * c_smallint", "category": "arithmetic", "sql": "SELECT c_num20_5 * c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 * c_integer", "category": "arithmetic", "sql": "SELECT c_num20_5 * c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 * c_bigint", "category": "arithmetic", "sql": "SELECT c_num20_5 * c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 * c_num10_2", "category": "arithmetic", "sql": "SELECT c_num20_5 * c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 * c_num20_5", "category": "arithmetic", "sql": "SELECT c_num20_5 * c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 * c_numeric", "category": "arithmetic", "sql": "SELECT c_num20_5 * c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 * c_real", "category": "arithmetic", "sql": "SELECT c_num20_5 * c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num20_5 * c_double", "category": "arithmetic", "sql": "SELECT c_num20_5 * c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_numeric * c_smallint", "category": "arithmetic", "sql": "SELECT c_numeric * c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric * c_integer", "category": "arithmetic", "sql": "SELECT c_numeric * c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric * c_bigint", "category": "arithmetic", "sql": "SELECT c_numeric * c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric * c_num10_2", "category": "arithmetic", "sql": "SELECT c_numeric * c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric * c_num20_5", "category": "arithmetic", "sql": "SELECT c_numeric * c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric * c_numeric", "category": "arithmetic", "sql": "SELECT c_numeric * c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric * c_real", "category": "arithmetic", "sql": "SELECT c_numeric * c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_numeric * c_double", "category": "arithmetic", "sql": "SELECT c_numeric * c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real * c_smallint", "category": "arithmetic", "sql": "SELECT c_real * c_smallint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real * c_integer", "category": "arithmetic", "sql": "SELECT c_real * c_integer AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real * c_bigint", "category": "arithmetic", "sql": "SELECT c_real * c_bigint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real * c_num10_2", "category": "arithmetic", "sql": "SELECT c_real * c_num10_2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real * c_num20_5", "category": "arithmetic", "sql": "SELECT c_real * c_num20_5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real * c_numeric", "category": "arithmetic", "sql": "SELECT c_real * c_numeric AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real * c_real", "category": "arithmetic", "sql": "SELECT c_real * c_real AS v FROM t", "type": "real"}, + {"id": "arithmetic: c_real * c_double", "category": "arithmetic", "sql": "SELECT c_real * c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double * c_smallint", "category": "arithmetic", "sql": "SELECT c_double * c_smallint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double * c_integer", "category": "arithmetic", "sql": "SELECT c_double * c_integer AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double * c_bigint", "category": "arithmetic", "sql": "SELECT c_double * c_bigint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double * c_num10_2", "category": "arithmetic", "sql": "SELECT c_double * c_num10_2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double * c_num20_5", "category": "arithmetic", "sql": "SELECT c_double * c_num20_5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double * c_numeric", "category": "arithmetic", "sql": "SELECT c_double * c_numeric AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double * c_real", "category": "arithmetic", "sql": "SELECT c_double * c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double * c_double", "category": "arithmetic", "sql": "SELECT c_double * c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_smallint / c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint / c_smallint AS v FROM t", "type": "smallint"}, + {"id": "arithmetic: c_smallint / c_integer", "category": "arithmetic", "sql": "SELECT c_smallint / c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_smallint / c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint / c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_smallint / c_num10_2", "category": "arithmetic", "sql": "SELECT c_smallint / c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint / c_num20_5", "category": "arithmetic", "sql": "SELECT c_smallint / c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint / c_numeric", "category": "arithmetic", "sql": "SELECT c_smallint / c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint / c_real", "category": "arithmetic", "sql": "SELECT c_smallint / c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_smallint / c_double", "category": "arithmetic", "sql": "SELECT c_smallint / c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_integer / c_smallint", "category": "arithmetic", "sql": "SELECT c_integer / c_smallint AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_integer / c_integer", "category": "arithmetic", "sql": "SELECT c_integer / c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_integer / c_bigint", "category": "arithmetic", "sql": "SELECT c_integer / c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_integer / c_num10_2", "category": "arithmetic", "sql": "SELECT c_integer / c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer / c_num20_5", "category": "arithmetic", "sql": "SELECT c_integer / c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer / c_numeric", "category": "arithmetic", "sql": "SELECT c_integer / c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer / c_real", "category": "arithmetic", "sql": "SELECT c_integer / c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_integer / c_double", "category": "arithmetic", "sql": "SELECT c_integer / c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_bigint / c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint / c_smallint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint / c_integer", "category": "arithmetic", "sql": "SELECT c_bigint / c_integer AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint / c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint / c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint / c_num10_2", "category": "arithmetic", "sql": "SELECT c_bigint / c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint / c_num20_5", "category": "arithmetic", "sql": "SELECT c_bigint / c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint / c_numeric", "category": "arithmetic", "sql": "SELECT c_bigint / c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint / c_real", "category": "arithmetic", "sql": "SELECT c_bigint / c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_bigint / c_double", "category": "arithmetic", "sql": "SELECT c_bigint / c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num10_2 / c_smallint", "category": "arithmetic", "sql": "SELECT c_num10_2 / c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 / c_integer", "category": "arithmetic", "sql": "SELECT c_num10_2 / c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 / c_bigint", "category": "arithmetic", "sql": "SELECT c_num10_2 / c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 / c_num10_2", "category": "arithmetic", "sql": "SELECT c_num10_2 / c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 / c_num20_5", "category": "arithmetic", "sql": "SELECT c_num10_2 / c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 / c_numeric", "category": "arithmetic", "sql": "SELECT c_num10_2 / c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 / c_real", "category": "arithmetic", "sql": "SELECT c_num10_2 / c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num10_2 / c_double", "category": "arithmetic", "sql": "SELECT c_num10_2 / c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num20_5 / c_smallint", "category": "arithmetic", "sql": "SELECT c_num20_5 / c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 / c_integer", "category": "arithmetic", "sql": "SELECT c_num20_5 / c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 / c_bigint", "category": "arithmetic", "sql": "SELECT c_num20_5 / c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 / c_num10_2", "category": "arithmetic", "sql": "SELECT c_num20_5 / c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 / c_num20_5", "category": "arithmetic", "sql": "SELECT c_num20_5 / c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 / c_numeric", "category": "arithmetic", "sql": "SELECT c_num20_5 / c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 / c_real", "category": "arithmetic", "sql": "SELECT c_num20_5 / c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_num20_5 / c_double", "category": "arithmetic", "sql": "SELECT c_num20_5 / c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_numeric / c_smallint", "category": "arithmetic", "sql": "SELECT c_numeric / c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric / c_integer", "category": "arithmetic", "sql": "SELECT c_numeric / c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric / c_bigint", "category": "arithmetic", "sql": "SELECT c_numeric / c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric / c_num10_2", "category": "arithmetic", "sql": "SELECT c_numeric / c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric / c_num20_5", "category": "arithmetic", "sql": "SELECT c_numeric / c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric / c_numeric", "category": "arithmetic", "sql": "SELECT c_numeric / c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric / c_real", "category": "arithmetic", "sql": "SELECT c_numeric / c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_numeric / c_double", "category": "arithmetic", "sql": "SELECT c_numeric / c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real / c_smallint", "category": "arithmetic", "sql": "SELECT c_real / c_smallint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real / c_integer", "category": "arithmetic", "sql": "SELECT c_real / c_integer AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real / c_bigint", "category": "arithmetic", "sql": "SELECT c_real / c_bigint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real / c_num10_2", "category": "arithmetic", "sql": "SELECT c_real / c_num10_2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real / c_num20_5", "category": "arithmetic", "sql": "SELECT c_real / c_num20_5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real / c_numeric", "category": "arithmetic", "sql": "SELECT c_real / c_numeric AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_real / c_real", "category": "arithmetic", "sql": "SELECT c_real / c_real AS v FROM t", "type": "real"}, + {"id": "arithmetic: c_real / c_double", "category": "arithmetic", "sql": "SELECT c_real / c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double / c_smallint", "category": "arithmetic", "sql": "SELECT c_double / c_smallint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double / c_integer", "category": "arithmetic", "sql": "SELECT c_double / c_integer AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double / c_bigint", "category": "arithmetic", "sql": "SELECT c_double / c_bigint AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double / c_num10_2", "category": "arithmetic", "sql": "SELECT c_double / c_num10_2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double / c_num20_5", "category": "arithmetic", "sql": "SELECT c_double / c_num20_5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double / c_numeric", "category": "arithmetic", "sql": "SELECT c_double / c_numeric AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double / c_real", "category": "arithmetic", "sql": "SELECT c_double / c_real AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_double / c_double", "category": "arithmetic", "sql": "SELECT c_double / c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic: c_smallint % c_smallint", "category": "arithmetic", "sql": "SELECT c_smallint % c_smallint AS v FROM t", "type": "smallint"}, + {"id": "arithmetic: c_smallint % c_integer", "category": "arithmetic", "sql": "SELECT c_smallint % c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_smallint % c_bigint", "category": "arithmetic", "sql": "SELECT c_smallint % c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_smallint % c_num10_2", "category": "arithmetic", "sql": "SELECT c_smallint % c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint % c_num20_5", "category": "arithmetic", "sql": "SELECT c_smallint % c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint % c_numeric", "category": "arithmetic", "sql": "SELECT c_smallint % c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_smallint % c_real", "category": "arithmetic", "sql": "SELECT c_smallint % c_real AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_smallint % c_double", "category": "arithmetic", "sql": "SELECT c_smallint % c_double AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_integer % c_smallint", "category": "arithmetic", "sql": "SELECT c_integer % c_smallint AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_integer % c_integer", "category": "arithmetic", "sql": "SELECT c_integer % c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic: c_integer % c_bigint", "category": "arithmetic", "sql": "SELECT c_integer % c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_integer % c_num10_2", "category": "arithmetic", "sql": "SELECT c_integer % c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer % c_num20_5", "category": "arithmetic", "sql": "SELECT c_integer % c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer % c_numeric", "category": "arithmetic", "sql": "SELECT c_integer % c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_integer % c_real", "category": "arithmetic", "sql": "SELECT c_integer % c_real AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_integer % c_double", "category": "arithmetic", "sql": "SELECT c_integer % c_double AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_bigint % c_smallint", "category": "arithmetic", "sql": "SELECT c_bigint % c_smallint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint % c_integer", "category": "arithmetic", "sql": "SELECT c_bigint % c_integer AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint % c_bigint", "category": "arithmetic", "sql": "SELECT c_bigint % c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic: c_bigint % c_num10_2", "category": "arithmetic", "sql": "SELECT c_bigint % c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint % c_num20_5", "category": "arithmetic", "sql": "SELECT c_bigint % c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint % c_numeric", "category": "arithmetic", "sql": "SELECT c_bigint % c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_bigint % c_real", "category": "arithmetic", "sql": "SELECT c_bigint % c_real AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_bigint % c_double", "category": "arithmetic", "sql": "SELECT c_bigint % c_double AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_num10_2 % c_smallint", "category": "arithmetic", "sql": "SELECT c_num10_2 % c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 % c_integer", "category": "arithmetic", "sql": "SELECT c_num10_2 % c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 % c_bigint", "category": "arithmetic", "sql": "SELECT c_num10_2 % c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 % c_num10_2", "category": "arithmetic", "sql": "SELECT c_num10_2 % c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 % c_num20_5", "category": "arithmetic", "sql": "SELECT c_num10_2 % c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 % c_numeric", "category": "arithmetic", "sql": "SELECT c_num10_2 % c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num10_2 % c_real", "category": "arithmetic", "sql": "SELECT c_num10_2 % c_real AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_num10_2 % c_double", "category": "arithmetic", "sql": "SELECT c_num10_2 % c_double AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_num20_5 % c_smallint", "category": "arithmetic", "sql": "SELECT c_num20_5 % c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 % c_integer", "category": "arithmetic", "sql": "SELECT c_num20_5 % c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 % c_bigint", "category": "arithmetic", "sql": "SELECT c_num20_5 % c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 % c_num10_2", "category": "arithmetic", "sql": "SELECT c_num20_5 % c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 % c_num20_5", "category": "arithmetic", "sql": "SELECT c_num20_5 % c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 % c_numeric", "category": "arithmetic", "sql": "SELECT c_num20_5 % c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_num20_5 % c_real", "category": "arithmetic", "sql": "SELECT c_num20_5 % c_real AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_num20_5 % c_double", "category": "arithmetic", "sql": "SELECT c_num20_5 % c_double AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_numeric % c_smallint", "category": "arithmetic", "sql": "SELECT c_numeric % c_smallint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric % c_integer", "category": "arithmetic", "sql": "SELECT c_numeric % c_integer AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric % c_bigint", "category": "arithmetic", "sql": "SELECT c_numeric % c_bigint AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric % c_num10_2", "category": "arithmetic", "sql": "SELECT c_numeric % c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric % c_num20_5", "category": "arithmetic", "sql": "SELECT c_numeric % c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric % c_numeric", "category": "arithmetic", "sql": "SELECT c_numeric % c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic: c_numeric % c_real", "category": "arithmetic", "sql": "SELECT c_numeric % c_real AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_numeric % c_double", "category": "arithmetic", "sql": "SELECT c_numeric % c_double AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_real % c_smallint", "category": "arithmetic", "sql": "SELECT c_real % c_smallint AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_real % c_integer", "category": "arithmetic", "sql": "SELECT c_real % c_integer AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_real % c_bigint", "category": "arithmetic", "sql": "SELECT c_real % c_bigint AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_real % c_num10_2", "category": "arithmetic", "sql": "SELECT c_real % c_num10_2 AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_real % c_num20_5", "category": "arithmetic", "sql": "SELECT c_real % c_num20_5 AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_real % c_numeric", "category": "arithmetic", "sql": "SELECT c_real % c_numeric AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_real % c_real", "category": "arithmetic", "sql": "SELECT c_real % c_real AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_real % c_double", "category": "arithmetic", "sql": "SELECT c_real % c_double AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_double % c_smallint", "category": "arithmetic", "sql": "SELECT c_double % c_smallint AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_double % c_integer", "category": "arithmetic", "sql": "SELECT c_double % c_integer AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_double % c_bigint", "category": "arithmetic", "sql": "SELECT c_double % c_bigint AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_double % c_num10_2", "category": "arithmetic", "sql": "SELECT c_double % c_num10_2 AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_double % c_num20_5", "category": "arithmetic", "sql": "SELECT c_double % c_num20_5 AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_double % c_numeric", "category": "arithmetic", "sql": "SELECT c_double % c_numeric AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_double % c_real", "category": "arithmetic", "sql": "SELECT c_double % c_real AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic: c_double % c_double", "category": "arithmetic", "sql": "SELECT c_double % c_double AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic_literal: 7 + 7", "category": "arithmetic_literal", "sql": "SELECT 7 + 7 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 7 + 2", "category": "arithmetic_literal", "sql": "SELECT 7 + 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 7 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 + 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 7 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 + 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 + 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 + 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 + 7", "category": "arithmetic_literal", "sql": "SELECT 2 + 7 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 2 + 2", "category": "arithmetic_literal", "sql": "SELECT 2 + 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 2 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 + 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 2 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 + 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 + 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 + 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 + 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 7 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 + 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 2 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 + 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 + 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 + 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 + 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 + 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 + 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 + 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 + 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 + 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 + 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 + 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 + 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 + 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 + 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 - 7", "category": "arithmetic_literal", "sql": "SELECT 7 - 7 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 7 - 2", "category": "arithmetic_literal", "sql": "SELECT 7 - 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 7 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 - 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 7 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 - 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 - 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 - 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 - 7", "category": "arithmetic_literal", "sql": "SELECT 2 - 7 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 2 - 2", "category": "arithmetic_literal", "sql": "SELECT 2 - 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 2 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 - 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 2 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 - 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 - 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 - 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 - 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 7 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 - 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 2 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 - 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 - 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 - 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 - 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 - 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 - 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 - 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 - 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 - 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 - 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 - 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 - 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 - 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 - 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 * 7", "category": "arithmetic_literal", "sql": "SELECT 7 * 7 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 7 * 2", "category": "arithmetic_literal", "sql": "SELECT 7 * 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 7 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 * 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 7 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 * 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 * 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 * 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 * 7", "category": "arithmetic_literal", "sql": "SELECT 2 * 7 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 2 * 2", "category": "arithmetic_literal", "sql": "SELECT 2 * 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 2 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 * 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 2 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 * 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 * 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 * 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 * 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 7 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 * 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 2 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 * 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 * 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 * 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 * 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 * 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 * 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 * 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 * 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 * 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 * 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 * 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 * 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 * 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 * 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 / 7", "category": "arithmetic_literal", "sql": "SELECT 7 / 7 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 7 / 2", "category": "arithmetic_literal", "sql": "SELECT 7 / 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 7 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 / 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 7 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 / 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 / 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 / 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 / 7", "category": "arithmetic_literal", "sql": "SELECT 2 / 7 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 2 / 2", "category": "arithmetic_literal", "sql": "SELECT 2 / 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 2 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 / 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 2 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 / 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 / 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 / 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 / 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 7 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 / 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 2 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 / 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 / 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 / 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 / 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 / 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 / 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 / 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 / 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 / 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 / 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 / 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 / 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 / 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 / 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 % 7", "category": "arithmetic_literal", "sql": "SELECT 7 % 7 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 7 % 2", "category": "arithmetic_literal", "sql": "SELECT 7 % 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 7 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 7 % 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 7 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 7 % 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 7 % 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 7 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 7 % 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 % 7", "category": "arithmetic_literal", "sql": "SELECT 2 % 7 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 2 % 2", "category": "arithmetic_literal", "sql": "SELECT 2 % 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: 2 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2 % 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 2 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 2 % 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 2 % 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 2 % 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 % 7", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 7 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 % 2", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 2 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: 3000000000 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 3000000000 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 3000000000 % 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 % 7", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 % 2", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1.5 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 1.5 % 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 % 7", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 % 2", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 2.25 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 2.25 % 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 % 7", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 7 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 % 2", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 % 3000000000", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 3000000000 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 % 1.5", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 % 2.25", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 2.25 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: 1e3 % 1e3", "category": "arithmetic_literal", "sql": "SELECT 1e3 % 1e3 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_integer + 2", "category": "arithmetic_literal", "sql": "SELECT c_integer + 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: c_integer + 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer + 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_bigint + 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint + 2 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: c_bigint + 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint + 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_numeric + 2", "category": "arithmetic_literal", "sql": "SELECT c_numeric + 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_numeric + 1.5", "category": "arithmetic_literal", "sql": "SELECT c_numeric + 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_double + 2", "category": "arithmetic_literal", "sql": "SELECT c_double + 2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic_literal: c_double + 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double + 1.5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic_literal: c_integer - 2", "category": "arithmetic_literal", "sql": "SELECT c_integer - 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: c_integer - 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer - 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_bigint - 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint - 2 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: c_bigint - 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint - 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_numeric - 2", "category": "arithmetic_literal", "sql": "SELECT c_numeric - 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_numeric - 1.5", "category": "arithmetic_literal", "sql": "SELECT c_numeric - 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_double - 2", "category": "arithmetic_literal", "sql": "SELECT c_double - 2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic_literal: c_double - 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double - 1.5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic_literal: c_integer * 2", "category": "arithmetic_literal", "sql": "SELECT c_integer * 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: c_integer * 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer * 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_bigint * 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint * 2 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: c_bigint * 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint * 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_numeric * 2", "category": "arithmetic_literal", "sql": "SELECT c_numeric * 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_numeric * 1.5", "category": "arithmetic_literal", "sql": "SELECT c_numeric * 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_double * 2", "category": "arithmetic_literal", "sql": "SELECT c_double * 2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic_literal: c_double * 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double * 1.5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic_literal: c_integer / 2", "category": "arithmetic_literal", "sql": "SELECT c_integer / 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: c_integer / 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer / 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_bigint / 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint / 2 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: c_bigint / 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint / 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_numeric / 2", "category": "arithmetic_literal", "sql": "SELECT c_numeric / 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_numeric / 1.5", "category": "arithmetic_literal", "sql": "SELECT c_numeric / 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_double / 2", "category": "arithmetic_literal", "sql": "SELECT c_double / 2 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic_literal: c_double / 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double / 1.5 AS v FROM t", "type": "double precision"}, + {"id": "arithmetic_literal: c_integer % 2", "category": "arithmetic_literal", "sql": "SELECT c_integer % 2 AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: c_integer % 1.5", "category": "arithmetic_literal", "sql": "SELECT c_integer % 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_bigint % 2", "category": "arithmetic_literal", "sql": "SELECT c_bigint % 2 AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: c_bigint % 1.5", "category": "arithmetic_literal", "sql": "SELECT c_bigint % 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_numeric % 2", "category": "arithmetic_literal", "sql": "SELECT c_numeric % 2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_numeric % 1.5", "category": "arithmetic_literal", "sql": "SELECT c_numeric % 1.5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: c_double % 2", "category": "arithmetic_literal", "sql": "SELECT c_double % 2 AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic_literal: c_double % 1.5", "category": "arithmetic_literal", "sql": "SELECT c_double % 1.5 AS v FROM t", "error": "UndefinedFunction"}, + {"id": "arithmetic_literal: SUM(c_integer) / COUNT(*)", "category": "arithmetic_literal", "sql": "SELECT SUM(c_integer) / COUNT(*) AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: -c_integer", "category": "arithmetic_literal", "sql": "SELECT -c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: -c_double", "category": "arithmetic_literal", "sql": "SELECT -c_double AS v FROM t", "type": "double precision"}, + {"id": "arithmetic_literal: -c_smallint", "category": "arithmetic_literal", "sql": "SELECT -c_smallint AS v FROM t", "type": "smallint"}, + {"id": "arithmetic_literal: -c_integer", "category": "arithmetic_literal", "sql": "SELECT -c_integer AS v FROM t", "type": "integer"}, + {"id": "arithmetic_literal: -c_bigint", "category": "arithmetic_literal", "sql": "SELECT -c_bigint AS v FROM t", "type": "bigint"}, + {"id": "arithmetic_literal: -c_num10_2", "category": "arithmetic_literal", "sql": "SELECT -c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: -c_num20_5", "category": "arithmetic_literal", "sql": "SELECT -c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: -c_numeric", "category": "arithmetic_literal", "sql": "SELECT -c_numeric AS v FROM t", "type": "numeric"}, + {"id": "arithmetic_literal: -c_real", "category": "arithmetic_literal", "sql": "SELECT -c_real AS v FROM t", "type": "real"}, + {"id": "arithmetic_literal: -c_double", "category": "arithmetic_literal", "sql": "SELECT -c_double AS v FROM t", "type": "double precision"}, + {"id": "concat: c_text || c_text", "category": "concat", "sql": "SELECT c_text || c_text AS v FROM t", "type": "text"}, + {"id": "concat: c_text || c_integer", "category": "concat", "sql": "SELECT c_text || c_integer AS v FROM t", "type": "text"}, + {"id": "concat: c_text || c_date", "category": "concat", "sql": "SELECT c_text || c_date AS v FROM t", "type": "text"}, + {"id": "concat: 'a' || 'b'", "category": "concat", "sql": "SELECT 'a' || 'b' AS v FROM t", "type": "text"}, + {"id": "concat: 'a' || c_text", "category": "concat", "sql": "SELECT 'a' || c_text AS v FROM t", "type": "text"}, + {"id": "concat: c_text || c_boolean", "category": "concat", "sql": "SELECT c_text || c_boolean AS v FROM t", "type": "text"}, + {"id": "concat: c_text || c_double", "category": "concat", "sql": "SELECT c_text || c_double AS v FROM t", "type": "text"}, + {"id": "concat: c_varchar || c_varchar", "category": "concat", "sql": "SELECT c_varchar || c_varchar AS v FROM t", "type": "text"}, + {"id": "concat: c_text || c_varchar", "category": "concat", "sql": "SELECT c_text || c_varchar AS v FROM t", "type": "text"}, + {"id": "concat: CONCAT(c_text, c_integer)", "category": "concat", "sql": "SELECT CONCAT(c_text, c_integer) AS v FROM t", "type": "text"}, + {"id": "concat: CONCAT(c_text, c_text)", "category": "concat", "sql": "SELECT CONCAT(c_text, c_text) AS v FROM t", "type": "text"}, + {"id": "concat: CONCAT_WS(',', c_text, c_integer)", "category": "concat", "sql": "SELECT CONCAT_WS(',', c_text, c_integer) AS v FROM t", "type": "text"}, + {"id": "comparison: c_integer = c_bigint", "category": "comparison", "sql": "SELECT c_integer = c_bigint AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_integer < c_double", "category": "comparison", "sql": "SELECT c_integer < c_double AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_text <> 'x'", "category": "comparison", "sql": "SELECT c_text <> 'x' AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_date >= c_timestamp", "category": "comparison", "sql": "SELECT c_date >= c_timestamp AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_boolean AND c_integer > 1", "category": "comparison", "sql": "SELECT c_boolean AND c_integer > 1 AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_boolean OR c_boolean", "category": "comparison", "sql": "SELECT c_boolean OR c_boolean AS v FROM t", "type": "boolean"}, + {"id": "comparison: NOT c_boolean", "category": "comparison", "sql": "SELECT NOT c_boolean AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_integer IS NULL", "category": "comparison", "sql": "SELECT c_integer IS NULL AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_integer IS NOT NULL", "category": "comparison", "sql": "SELECT c_integer IS NOT NULL AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_integer BETWEEN 1 AND 3", "category": "comparison", "sql": "SELECT c_integer BETWEEN 1 AND 3 AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_integer IN (1, 2)", "category": "comparison", "sql": "SELECT c_integer IN (1, 2) AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_text LIKE 'a%'", "category": "comparison", "sql": "SELECT c_text LIKE 'a%' AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_text ILIKE 'a%'", "category": "comparison", "sql": "SELECT c_text ILIKE 'a%' AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_text NOT LIKE 'a%'", "category": "comparison", "sql": "SELECT c_text NOT LIKE 'a%' AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_boolean IS TRUE", "category": "comparison", "sql": "SELECT c_boolean IS TRUE AS v FROM t", "type": "boolean"}, + {"id": "comparison: c_integer IS DISTINCT FROM c_bigint", "category": "comparison", "sql": "SELECT c_integer IS DISTINCT FROM c_bigint AS v FROM t", "type": "boolean"}, + {"id": "comparison: EXISTS (SELECT 1)", "category": "comparison", "sql": "SELECT EXISTS (SELECT 1) AS v FROM t", "type": "boolean"}, + {"id": "aggregate: SUM(c_smallint)", "category": "aggregate", "sql": "SELECT SUM(c_smallint) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: SUM(c_integer)", "category": "aggregate", "sql": "SELECT SUM(c_integer) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: SUM(c_bigint)", "category": "aggregate", "sql": "SELECT SUM(c_bigint) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: SUM(c_num10_2)", "category": "aggregate", "sql": "SELECT SUM(c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: SUM(c_num20_5)", "category": "aggregate", "sql": "SELECT SUM(c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: SUM(c_numeric)", "category": "aggregate", "sql": "SELECT SUM(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: SUM(c_real)", "category": "aggregate", "sql": "SELECT SUM(c_real) AS v FROM t", "type": "real"}, + {"id": "aggregate: SUM(c_double)", "category": "aggregate", "sql": "SELECT SUM(c_double) AS v FROM t", "type": "double precision"}, + {"id": "aggregate: SUM(c_text)", "category": "aggregate", "sql": "SELECT SUM(c_text) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: SUM(c_boolean)", "category": "aggregate", "sql": "SELECT SUM(c_boolean) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: SUM(c_date)", "category": "aggregate", "sql": "SELECT SUM(c_date) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: SUM(c_timestamp)", "category": "aggregate", "sql": "SELECT SUM(c_timestamp) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: SUM(c_interval)", "category": "aggregate", "sql": "SELECT SUM(c_interval) AS v FROM t", "type": "interval"}, + {"id": "aggregate: AVG(c_smallint)", "category": "aggregate", "sql": "SELECT AVG(c_smallint) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: AVG(c_integer)", "category": "aggregate", "sql": "SELECT AVG(c_integer) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: AVG(c_bigint)", "category": "aggregate", "sql": "SELECT AVG(c_bigint) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: AVG(c_num10_2)", "category": "aggregate", "sql": "SELECT AVG(c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: AVG(c_num20_5)", "category": "aggregate", "sql": "SELECT AVG(c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: AVG(c_numeric)", "category": "aggregate", "sql": "SELECT AVG(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: AVG(c_real)", "category": "aggregate", "sql": "SELECT AVG(c_real) AS v FROM t", "type": "double precision"}, + {"id": "aggregate: AVG(c_double)", "category": "aggregate", "sql": "SELECT AVG(c_double) AS v FROM t", "type": "double precision"}, + {"id": "aggregate: AVG(c_text)", "category": "aggregate", "sql": "SELECT AVG(c_text) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: AVG(c_boolean)", "category": "aggregate", "sql": "SELECT AVG(c_boolean) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: AVG(c_date)", "category": "aggregate", "sql": "SELECT AVG(c_date) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: AVG(c_timestamp)", "category": "aggregate", "sql": "SELECT AVG(c_timestamp) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: AVG(c_interval)", "category": "aggregate", "sql": "SELECT AVG(c_interval) AS v FROM t", "type": "interval"}, + {"id": "aggregate: MIN(c_smallint)", "category": "aggregate", "sql": "SELECT MIN(c_smallint) AS v FROM t", "type": "smallint"}, + {"id": "aggregate: MIN(c_integer)", "category": "aggregate", "sql": "SELECT MIN(c_integer) AS v FROM t", "type": "integer"}, + {"id": "aggregate: MIN(c_bigint)", "category": "aggregate", "sql": "SELECT MIN(c_bigint) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: MIN(c_num10_2)", "category": "aggregate", "sql": "SELECT MIN(c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: MIN(c_num20_5)", "category": "aggregate", "sql": "SELECT MIN(c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: MIN(c_numeric)", "category": "aggregate", "sql": "SELECT MIN(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: MIN(c_real)", "category": "aggregate", "sql": "SELECT MIN(c_real) AS v FROM t", "type": "real"}, + {"id": "aggregate: MIN(c_double)", "category": "aggregate", "sql": "SELECT MIN(c_double) AS v FROM t", "type": "double precision"}, + {"id": "aggregate: MIN(c_text)", "category": "aggregate", "sql": "SELECT MIN(c_text) AS v FROM t", "type": "text"}, + {"id": "aggregate: MIN(c_boolean)", "category": "aggregate", "sql": "SELECT MIN(c_boolean) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: MIN(c_date)", "category": "aggregate", "sql": "SELECT MIN(c_date) AS v FROM t", "type": "date"}, + {"id": "aggregate: MIN(c_timestamp)", "category": "aggregate", "sql": "SELECT MIN(c_timestamp) AS v FROM t", "type": "timestamp without time zone"}, + {"id": "aggregate: MIN(c_interval)", "category": "aggregate", "sql": "SELECT MIN(c_interval) AS v FROM t", "type": "interval"}, + {"id": "aggregate: MAX(c_smallint)", "category": "aggregate", "sql": "SELECT MAX(c_smallint) AS v FROM t", "type": "smallint"}, + {"id": "aggregate: MAX(c_integer)", "category": "aggregate", "sql": "SELECT MAX(c_integer) AS v FROM t", "type": "integer"}, + {"id": "aggregate: MAX(c_bigint)", "category": "aggregate", "sql": "SELECT MAX(c_bigint) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: MAX(c_num10_2)", "category": "aggregate", "sql": "SELECT MAX(c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: MAX(c_num20_5)", "category": "aggregate", "sql": "SELECT MAX(c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: MAX(c_numeric)", "category": "aggregate", "sql": "SELECT MAX(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: MAX(c_real)", "category": "aggregate", "sql": "SELECT MAX(c_real) AS v FROM t", "type": "real"}, + {"id": "aggregate: MAX(c_double)", "category": "aggregate", "sql": "SELECT MAX(c_double) AS v FROM t", "type": "double precision"}, + {"id": "aggregate: MAX(c_text)", "category": "aggregate", "sql": "SELECT MAX(c_text) AS v FROM t", "type": "text"}, + {"id": "aggregate: MAX(c_boolean)", "category": "aggregate", "sql": "SELECT MAX(c_boolean) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: MAX(c_date)", "category": "aggregate", "sql": "SELECT MAX(c_date) AS v FROM t", "type": "date"}, + {"id": "aggregate: MAX(c_timestamp)", "category": "aggregate", "sql": "SELECT MAX(c_timestamp) AS v FROM t", "type": "timestamp without time zone"}, + {"id": "aggregate: MAX(c_interval)", "category": "aggregate", "sql": "SELECT MAX(c_interval) AS v FROM t", "type": "interval"}, + {"id": "aggregate: COUNT(c_smallint)", "category": "aggregate", "sql": "SELECT COUNT(c_smallint) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_integer)", "category": "aggregate", "sql": "SELECT COUNT(c_integer) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_bigint)", "category": "aggregate", "sql": "SELECT COUNT(c_bigint) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_num10_2)", "category": "aggregate", "sql": "SELECT COUNT(c_num10_2) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_num20_5)", "category": "aggregate", "sql": "SELECT COUNT(c_num20_5) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_numeric)", "category": "aggregate", "sql": "SELECT COUNT(c_numeric) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_real)", "category": "aggregate", "sql": "SELECT COUNT(c_real) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_double)", "category": "aggregate", "sql": "SELECT COUNT(c_double) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_text)", "category": "aggregate", "sql": "SELECT COUNT(c_text) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_boolean)", "category": "aggregate", "sql": "SELECT COUNT(c_boolean) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_date)", "category": "aggregate", "sql": "SELECT COUNT(c_date) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_timestamp)", "category": "aggregate", "sql": "SELECT COUNT(c_timestamp) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: COUNT(c_interval)", "category": "aggregate", "sql": "SELECT COUNT(c_interval) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: STDDEV(c_smallint)", "category": "aggregate", "sql": "SELECT STDDEV(c_smallint) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: STDDEV(c_integer)", "category": "aggregate", "sql": "SELECT STDDEV(c_integer) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: STDDEV(c_bigint)", "category": "aggregate", "sql": "SELECT STDDEV(c_bigint) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: STDDEV(c_num10_2)", "category": "aggregate", "sql": "SELECT STDDEV(c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: STDDEV(c_num20_5)", "category": "aggregate", "sql": "SELECT STDDEV(c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: STDDEV(c_numeric)", "category": "aggregate", "sql": "SELECT STDDEV(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: STDDEV(c_real)", "category": "aggregate", "sql": "SELECT STDDEV(c_real) AS v FROM t", "type": "double precision"}, + {"id": "aggregate: STDDEV(c_double)", "category": "aggregate", "sql": "SELECT STDDEV(c_double) AS v FROM t", "type": "double precision"}, + {"id": "aggregate: STDDEV(c_text)", "category": "aggregate", "sql": "SELECT STDDEV(c_text) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: STDDEV(c_boolean)", "category": "aggregate", "sql": "SELECT STDDEV(c_boolean) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: STDDEV(c_date)", "category": "aggregate", "sql": "SELECT STDDEV(c_date) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: STDDEV(c_timestamp)", "category": "aggregate", "sql": "SELECT STDDEV(c_timestamp) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: STDDEV(c_interval)", "category": "aggregate", "sql": "SELECT STDDEV(c_interval) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "aggregate: COUNT(*)", "category": "aggregate", "sql": "SELECT COUNT(*) AS v FROM t", "type": "bigint"}, + {"id": "aggregate: VARIANCE(c_integer)", "category": "aggregate", "sql": "SELECT VARIANCE(c_integer) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: VARIANCE(c_numeric)", "category": "aggregate", "sql": "SELECT VARIANCE(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: VARIANCE(c_double)", "category": "aggregate", "sql": "SELECT VARIANCE(c_double) AS v FROM t", "type": "double precision"}, + {"id": "aggregate: STDDEV_POP(c_integer)", "category": "aggregate", "sql": "SELECT STDDEV_POP(c_integer) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: STDDEV_POP(c_numeric)", "category": "aggregate", "sql": "SELECT STDDEV_POP(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: STDDEV_POP(c_double)", "category": "aggregate", "sql": "SELECT STDDEV_POP(c_double) AS v FROM t", "type": "double precision"}, + {"id": "aggregate: VAR_POP(c_integer)", "category": "aggregate", "sql": "SELECT VAR_POP(c_integer) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: VAR_POP(c_numeric)", "category": "aggregate", "sql": "SELECT VAR_POP(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "aggregate: VAR_POP(c_double)", "category": "aggregate", "sql": "SELECT VAR_POP(c_double) AS v FROM t", "type": "double precision"}, + {"id": "aggregate: BOOL_AND(c_boolean)", "category": "aggregate", "sql": "SELECT BOOL_AND(c_boolean) AS v FROM t", "type": "boolean"}, + {"id": "aggregate: BOOL_OR(c_boolean)", "category": "aggregate", "sql": "SELECT BOOL_OR(c_boolean) AS v FROM t", "type": "boolean"}, + {"id": "aggregate: STRING_AGG(c_text, ',')", "category": "aggregate", "sql": "SELECT STRING_AGG(c_text, ',') AS v FROM t", "type": "text"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_smallint END AS v FROM t", "type": "smallint"}, + {"id": "conditional: COALESCE(c_smallint, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_smallint) AS v FROM t", "type": "smallint"}, + {"id": "conditional: NULLIF(c_smallint, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_smallint) AS v FROM t", "type": "smallint"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_integer END AS v FROM t", "type": "integer"}, + {"id": "conditional: COALESCE(c_smallint, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_integer) AS v FROM t", "type": "integer"}, + {"id": "conditional: NULLIF(c_smallint, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_integer) AS v FROM t", "type": "smallint"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_bigint END AS v FROM t", "type": "bigint"}, + {"id": "conditional: COALESCE(c_smallint, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_bigint) AS v FROM t", "type": "bigint"}, + {"id": "conditional: NULLIF(c_smallint, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_bigint) AS v FROM t", "type": "smallint"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_num10_2 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_smallint, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_smallint, c_num10_2)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_num20_5 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_smallint, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_smallint, c_num20_5)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_numeric END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_smallint, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_smallint, c_numeric)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_real END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_smallint, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_real) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_smallint, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_real) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_double END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_smallint, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_smallint, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_smallint, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_text END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_smallint, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_text) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_date END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_smallint, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_date) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_smallint ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_smallint ELSE c_timestamp END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_smallint, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_smallint, c_timestamp) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_smallint END AS v FROM t", "type": "integer"}, + {"id": "conditional: COALESCE(c_integer, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_smallint) AS v FROM t", "type": "integer"}, + {"id": "conditional: NULLIF(c_integer, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_smallint) AS v FROM t", "type": "integer"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_integer END AS v FROM t", "type": "integer"}, + {"id": "conditional: COALESCE(c_integer, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_integer) AS v FROM t", "type": "integer"}, + {"id": "conditional: NULLIF(c_integer, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_integer) AS v FROM t", "type": "integer"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_bigint END AS v FROM t", "type": "bigint"}, + {"id": "conditional: COALESCE(c_integer, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_bigint) AS v FROM t", "type": "bigint"}, + {"id": "conditional: NULLIF(c_integer, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_bigint) AS v FROM t", "type": "integer"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_num10_2 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_integer, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_integer, c_num10_2)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_num20_5 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_integer, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_integer, c_num20_5)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_numeric END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_integer, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_integer, c_numeric)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_real END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_integer, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_real) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_integer, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_real) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_double END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_integer, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_integer, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_integer, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_text END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_integer, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_text) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_date END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_integer, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_date) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE c_timestamp END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_integer, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, c_timestamp) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_smallint END AS v FROM t", "type": "bigint"}, + {"id": "conditional: COALESCE(c_bigint, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_smallint) AS v FROM t", "type": "bigint"}, + {"id": "conditional: NULLIF(c_bigint, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_smallint) AS v FROM t", "type": "bigint"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_integer END AS v FROM t", "type": "bigint"}, + {"id": "conditional: COALESCE(c_bigint, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_integer) AS v FROM t", "type": "bigint"}, + {"id": "conditional: NULLIF(c_bigint, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_integer) AS v FROM t", "type": "bigint"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_bigint END AS v FROM t", "type": "bigint"}, + {"id": "conditional: COALESCE(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_bigint) AS v FROM t", "type": "bigint"}, + {"id": "conditional: NULLIF(c_bigint, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_bigint) AS v FROM t", "type": "bigint"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_num10_2 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_bigint, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_bigint, c_num10_2)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_num20_5 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_bigint, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_bigint, c_num20_5)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_numeric END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_bigint, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_bigint, c_numeric)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_real END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_bigint, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_real) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_bigint, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_real) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_double END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_bigint, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_bigint, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_bigint, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_text END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_bigint, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_text) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_date END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_bigint, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_date) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_bigint ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_bigint ELSE c_timestamp END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_bigint, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_bigint, c_timestamp) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_smallint END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_num10_2, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_smallint) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_num10_2, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_num10_2, c_smallint) AS v FROM t", "type": "numeric(10,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_integer END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_num10_2, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_integer) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_num10_2, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_num10_2, c_integer) AS v FROM t", "type": "numeric(10,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_bigint END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_num10_2, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_bigint) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_num10_2, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_num10_2, c_bigint) AS v FROM t", "type": "numeric(10,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_num10_2 END AS v FROM t", "type": "numeric(10,2)"}, + {"id": "conditional: COALESCE(c_num10_2, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_num10_2) AS v FROM t", "type": "numeric(10,2)"}, + {"id": "conditional: NULLIF(c_num10_2, c_num10_2)", "category": "conditional", "sql": "SELECT NULLIF(c_num10_2, c_num10_2) AS v FROM t", "type": "numeric(10,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_num20_5 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_num10_2, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_num10_2, c_num20_5)", "category": "conditional", "sql": "SELECT NULLIF(c_num10_2, c_num20_5) AS v FROM t", "type": "numeric(10,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_numeric END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_num10_2, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_num10_2, c_numeric)", "category": "conditional", "sql": "SELECT NULLIF(c_num10_2, c_numeric) AS v FROM t", "type": "numeric(10,2)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_real END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_num10_2, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_real) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_num10_2, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_num10_2, c_real) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_double END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_num10_2, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_num10_2, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_num10_2, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_text END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_num10_2, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_text) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_date END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_num10_2, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_date) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num10_2 ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num10_2 ELSE c_timestamp END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_num10_2, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_num10_2, c_timestamp) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_smallint END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_num20_5, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_smallint) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_num20_5, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_num20_5, c_smallint) AS v FROM t", "type": "numeric(20,5)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_integer END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_num20_5, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_integer) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_num20_5, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_num20_5, c_integer) AS v FROM t", "type": "numeric(20,5)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_bigint END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_num20_5, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_bigint) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_num20_5, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_num20_5, c_bigint) AS v FROM t", "type": "numeric(20,5)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_num10_2 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_num20_5, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_num20_5, c_num10_2)", "category": "conditional", "sql": "SELECT NULLIF(c_num20_5, c_num10_2) AS v FROM t", "type": "numeric(20,5)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_num20_5 END AS v FROM t", "type": "numeric(20,5)"}, + {"id": "conditional: COALESCE(c_num20_5, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_num20_5) AS v FROM t", "type": "numeric(20,5)"}, + {"id": "conditional: NULLIF(c_num20_5, c_num20_5)", "category": "conditional", "sql": "SELECT NULLIF(c_num20_5, c_num20_5) AS v FROM t", "type": "numeric(20,5)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_numeric END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_num20_5, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_num20_5, c_numeric)", "category": "conditional", "sql": "SELECT NULLIF(c_num20_5, c_numeric) AS v FROM t", "type": "numeric(20,5)"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_real END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_num20_5, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_real) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_num20_5, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_num20_5, c_real) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_double END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_num20_5, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_num20_5, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_num20_5, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_text END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_num20_5, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_text) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_date END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_num20_5, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_date) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_num20_5 ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_num20_5 ELSE c_timestamp END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_num20_5, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_num20_5, c_timestamp) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_smallint END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_numeric, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_smallint) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_numeric, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_numeric, c_smallint) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_integer END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_numeric, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_integer) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_numeric, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_numeric, c_integer) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_bigint END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_numeric, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_bigint) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_numeric, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_numeric, c_bigint) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_num10_2 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_numeric, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_numeric, c_num10_2)", "category": "conditional", "sql": "SELECT NULLIF(c_numeric, c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_num20_5 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_numeric, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_numeric, c_num20_5)", "category": "conditional", "sql": "SELECT NULLIF(c_numeric, c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_numeric END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_numeric, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "conditional: NULLIF(c_numeric, c_numeric)", "category": "conditional", "sql": "SELECT NULLIF(c_numeric, c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_real END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_numeric, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_real) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_numeric, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_numeric, c_real) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_double END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_numeric, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_numeric, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_numeric, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_text END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_numeric, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_text) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_date END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_numeric, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_date) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_numeric ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_numeric ELSE c_timestamp END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_numeric, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_numeric, c_timestamp) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_smallint END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_real, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_smallint) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_real, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_smallint) AS v FROM t", "type": "real"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_integer END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_real, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_integer) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_real, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_integer) AS v FROM t", "type": "real"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_bigint END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_real, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_bigint) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_real, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_bigint) AS v FROM t", "type": "real"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_num10_2 END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_real, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_num10_2) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_real, c_num10_2)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_num10_2) AS v FROM t", "type": "real"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_num20_5 END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_real, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_num20_5) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_real, c_num20_5)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_num20_5) AS v FROM t", "type": "real"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_numeric END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_real, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_numeric) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_real, c_numeric)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_numeric) AS v FROM t", "type": "real"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_real END AS v FROM t", "type": "real"}, + {"id": "conditional: COALESCE(c_real, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_real) AS v FROM t", "type": "real"}, + {"id": "conditional: NULLIF(c_real, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_real) AS v FROM t", "type": "real"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_double END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_real, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_real, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_real, c_double) AS v FROM t", "type": "real"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_text END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_real, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_text) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_date END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_real, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_date) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_real ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_real ELSE c_timestamp END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_real, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_real, c_timestamp) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_smallint END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_double, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_smallint) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_double, c_smallint)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_smallint) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_integer END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_double, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_integer) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_double, c_integer)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_integer) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_bigint END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_double, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_bigint) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_double, c_bigint)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_bigint) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_num10_2 END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_double, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_num10_2) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_double, c_num10_2)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_num10_2) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_num20_5 END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_double, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_num20_5) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_double, c_num20_5)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_num20_5) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_numeric END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_double, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_numeric) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_double, c_numeric)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_numeric) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_real END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_double, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_real) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_double, c_real)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_real) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_double END AS v FROM t", "type": "double precision"}, + {"id": "conditional: COALESCE(c_double, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: NULLIF(c_double, c_double)", "category": "conditional", "sql": "SELECT NULLIF(c_double, c_double) AS v FROM t", "type": "double precision"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_text END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_double, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_text) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_date END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_double, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_date) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_double ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_double ELSE c_timestamp END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_double, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_double, c_timestamp) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_smallint END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_text, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_smallint) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_integer END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_text, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_integer) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_bigint END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_text, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_bigint) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_num10_2 END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_text, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_num10_2) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_num20_5 END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_text, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_num20_5) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_numeric END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_text, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_numeric) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_real END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_text, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_real) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_double END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_text, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_double) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_text END AS v FROM t", "type": "text"}, + {"id": "conditional: COALESCE(c_text, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_text) AS v FROM t", "type": "text"}, + {"id": "conditional: NULLIF(c_text, c_text)", "category": "conditional", "sql": "SELECT NULLIF(c_text, c_text) AS v FROM t", "type": "text"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_date END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_text, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_date) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_text ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_text ELSE c_timestamp END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_text, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_text, c_timestamp) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_smallint END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_date, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_smallint) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_integer END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_date, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_integer) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_bigint END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_date, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_bigint) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_num10_2 END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_date, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_num10_2) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_num20_5 END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_date, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_num20_5) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_numeric END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_date, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_numeric) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_real END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_date, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_real) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_double END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_date, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_double) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_text END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_date, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_text) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_date END AS v FROM t", "type": "date"}, + {"id": "conditional: COALESCE(c_date, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_date) AS v FROM t", "type": "date"}, + {"id": "conditional: NULLIF(c_date, c_date)", "category": "conditional", "sql": "SELECT NULLIF(c_date, c_date) AS v FROM t", "type": "date"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_date ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_date ELSE c_timestamp END AS v FROM t", "type": "timestamp without time zone"}, + {"id": "conditional: COALESCE(c_date, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_date, c_timestamp) AS v FROM t", "type": "timestamp without time zone"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_smallint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_smallint END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_timestamp, c_smallint)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_smallint) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_integer END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_integer END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_timestamp, c_integer)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_integer) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_bigint END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_bigint END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_timestamp, c_bigint)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_bigint) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_num10_2 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_num10_2 END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_timestamp, c_num10_2)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_num10_2) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_num20_5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_num20_5 END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_timestamp, c_num20_5)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_num20_5) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_numeric END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_numeric END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_timestamp, c_numeric)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_numeric) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_real END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_real END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_timestamp, c_real)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_real) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_double END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_double END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_timestamp, c_double)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_double) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_text END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_text END AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: COALESCE(c_timestamp, c_text)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_text) AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_date END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_date END AS v FROM t", "type": "timestamp without time zone"}, + {"id": "conditional: COALESCE(c_timestamp, c_date)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_date) AS v FROM t", "type": "timestamp without time zone"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_timestamp ELSE c_timestamp END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_timestamp ELSE c_timestamp END AS v FROM t", "type": "timestamp without time zone"}, + {"id": "conditional: COALESCE(c_timestamp, c_timestamp)", "category": "conditional", "sql": "SELECT COALESCE(c_timestamp, c_timestamp) AS v FROM t", "type": "timestamp without time zone"}, + {"id": "conditional: NULLIF(c_timestamp, c_timestamp)", "category": "conditional", "sql": "SELECT NULLIF(c_timestamp, c_timestamp) AS v FROM t", "type": "timestamp without time zone"}, + {"id": "conditional: COALESCE(c_integer, 1)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, 1) AS v FROM t", "type": "integer"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE 1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE 1 END AS v FROM t", "type": "integer"}, + {"id": "conditional: COALESCE(c_integer, 1.5)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, 1.5) AS v FROM t", "type": "numeric"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE 1.5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE 1.5 END AS v FROM t", "type": "numeric"}, + {"id": "conditional: COALESCE(c_integer, 'x')", "category": "conditional", "sql": "SELECT COALESCE(c_integer, 'x') AS v FROM t", "error": "InvalidTextRepresentation"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE 'x' END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE 'x' END AS v FROM t", "error": "InvalidTextRepresentation"}, + {"id": "conditional: COALESCE(c_integer, NULL)", "category": "conditional", "sql": "SELECT COALESCE(c_integer, NULL) AS v FROM t", "type": "integer"}, + {"id": "conditional: CASE WHEN c_boolean THEN c_integer ELSE NULL END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN c_integer ELSE NULL END AS v FROM t", "type": "integer"}, + {"id": "conditional: CASE WHEN c_boolean THEN 1 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN 1 END AS v FROM t", "type": "integer"}, + {"id": "conditional: CASE WHEN c_boolean THEN 1 ELSE 2.5 END", "category": "conditional", "sql": "SELECT CASE WHEN c_boolean THEN 1 ELSE 2.5 END AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_smallint UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "smallint"}, + {"id": "set_operation: c_smallint UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "integer"}, + {"id": "set_operation: c_smallint UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "bigint"}, + {"id": "set_operation: c_smallint UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_smallint UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_smallint UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_smallint UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "real"}, + {"id": "set_operation: c_smallint UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_smallint UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_text AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_smallint UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_smallint UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_smallint AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_integer UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "integer"}, + {"id": "set_operation: c_integer UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "integer"}, + {"id": "set_operation: c_integer UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "bigint"}, + {"id": "set_operation: c_integer UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_integer UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_integer UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_integer UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "real"}, + {"id": "set_operation: c_integer UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_integer UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_text AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_integer UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_integer UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_integer AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_bigint UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "bigint"}, + {"id": "set_operation: c_bigint UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "bigint"}, + {"id": "set_operation: c_bigint UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "bigint"}, + {"id": "set_operation: c_bigint UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_bigint UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_bigint UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_bigint UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "real"}, + {"id": "set_operation: c_bigint UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_bigint UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_text AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_bigint UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_bigint UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_bigint AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_num10_2 UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_num10_2 UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_num10_2 UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_num10_2 UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "type": "numeric(10,2)"}, + {"id": "set_operation: c_num10_2 UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_num10_2 UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_num10_2 UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "real"}, + {"id": "set_operation: c_num10_2 UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_num10_2 UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_text AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_num10_2 UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_num10_2 UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_num10_2 AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_num20_5 UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_num20_5 UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_num20_5 UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_num20_5 UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_num20_5 UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "type": "numeric(20,5)"}, + {"id": "set_operation: c_num20_5 UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_num20_5 UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "real"}, + {"id": "set_operation: c_num20_5 UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_num20_5 UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_text AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_num20_5 UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_num20_5 UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_num20_5 AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_numeric UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_numeric UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_numeric UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_numeric UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_numeric UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_numeric UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "type": "numeric"}, + {"id": "set_operation: c_numeric UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "real"}, + {"id": "set_operation: c_numeric UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_numeric UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_text AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_numeric UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_numeric UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_numeric AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_real UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "real"}, + {"id": "set_operation: c_real UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "real"}, + {"id": "set_operation: c_real UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "real"}, + {"id": "set_operation: c_real UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "type": "real"}, + {"id": "set_operation: c_real UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "type": "real"}, + {"id": "set_operation: c_real UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "type": "real"}, + {"id": "set_operation: c_real UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "real"}, + {"id": "set_operation: c_real UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_real UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_text AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_real UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_real UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_real AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_double UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_double UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_double UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_double UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_double UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_double UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_double UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_real AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_double UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_double AS v FROM t", "type": "double precision"}, + {"id": "set_operation: c_double UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_text AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_double UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_double UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_double AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_text UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_text UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_text UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_text UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_text UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_text UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_text UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_real AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_text UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_double AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_text UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_text AS v FROM t", "type": "text"}, + {"id": "set_operation: c_text UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_date AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_text UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_text AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_date UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_date UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_date UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_date UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_date UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_date UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_date UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_real AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_date UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_double AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_date UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_text AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_date UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_date AS v FROM t", "type": "date"}, + {"id": "set_operation: c_date UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_date AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "type": "timestamp without time zone"}, + {"id": "set_operation: c_timestamp UNION ALL c_smallint", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_smallint AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_timestamp UNION ALL c_integer", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_timestamp UNION ALL c_bigint", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_bigint AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_timestamp UNION ALL c_num10_2", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_num10_2 AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_timestamp UNION ALL c_num20_5", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_num20_5 AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_timestamp UNION ALL c_numeric", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_numeric AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_timestamp UNION ALL c_real", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_real AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_timestamp UNION ALL c_double", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_double AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_timestamp UNION ALL c_text", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_text AS v FROM t", "error": "DatatypeMismatch"}, + {"id": "set_operation: c_timestamp UNION ALL c_date", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_date AS v FROM t", "type": "timestamp without time zone"}, + {"id": "set_operation: c_timestamp UNION ALL c_timestamp", "category": "set_operation", "sql": "SELECT c_timestamp AS v FROM t UNION ALL SELECT c_timestamp AS v FROM t", "type": "timestamp without time zone"}, + {"id": "set_operation: 1 UNION ALL 2.5", "category": "set_operation", "sql": "SELECT 1 AS v FROM t UNION ALL SELECT 2.5 AS v FROM t", "type": "numeric"}, + {"id": "set_operation: 1 UNION ALL 3000000000", "category": "set_operation", "sql": "SELECT 1 AS v FROM t UNION ALL SELECT 3000000000 AS v FROM t", "type": "bigint"}, + {"id": "set_operation: 'a' UNION ALL 'bc'", "category": "set_operation", "sql": "SELECT 'a' AS v FROM t UNION ALL SELECT 'bc' AS v FROM t", "type": "text"}, + {"id": "set_operation: NULL UNION ALL c_integer", "category": "set_operation", "sql": "SELECT NULL AS v FROM t UNION ALL SELECT c_integer AS v FROM t", "type": "integer"}, + {"id": "datetime: c_date + 1", "category": "datetime", "sql": "SELECT c_date + 1 AS v FROM t", "type": "date"}, + {"id": "datetime: 1 + c_date", "category": "datetime", "sql": "SELECT 1 + c_date AS v FROM t", "type": "date"}, + {"id": "datetime: c_date - 1", "category": "datetime", "sql": "SELECT c_date - 1 AS v FROM t", "type": "date"}, + {"id": "datetime: c_date - c_date", "category": "datetime", "sql": "SELECT c_date - c_date AS v FROM t", "type": "integer"}, + {"id": "datetime: c_date + INTERVAL '1 day'", "category": "datetime", "sql": "SELECT c_date + INTERVAL '1 day' AS v FROM t", "type": "timestamp without time zone"}, + {"id": "datetime: c_date - INTERVAL '1 day'", "category": "datetime", "sql": "SELECT c_date - INTERVAL '1 day' AS v FROM t", "type": "timestamp without time zone"}, + {"id": "datetime: c_timestamp + INTERVAL '1 day'", "category": "datetime", "sql": "SELECT c_timestamp + INTERVAL '1 day' AS v FROM t", "type": "timestamp without time zone"}, + {"id": "datetime: c_timestamp - INTERVAL '1 day'", "category": "datetime", "sql": "SELECT c_timestamp - INTERVAL '1 day' AS v FROM t", "type": "timestamp without time zone"}, + {"id": "datetime: c_timestamptz + INTERVAL '1 day'", "category": "datetime", "sql": "SELECT c_timestamptz + INTERVAL '1 day' AS v FROM t", "type": "timestamp with time zone"}, + {"id": "datetime: c_timestamp - c_timestamp", "category": "datetime", "sql": "SELECT c_timestamp - c_timestamp AS v FROM t", "type": "interval"}, + {"id": "datetime: c_timestamptz - c_timestamptz", "category": "datetime", "sql": "SELECT c_timestamptz - c_timestamptz AS v FROM t", "type": "interval"}, + {"id": "datetime: c_date - c_timestamp", "category": "datetime", "sql": "SELECT c_date - c_timestamp AS v FROM t", "type": "interval"}, + {"id": "datetime: c_time + INTERVAL '1 day'", "category": "datetime", "sql": "SELECT c_time + INTERVAL '1 day' AS v FROM t", "type": "time without time zone"}, + {"id": "datetime: c_time - c_time", "category": "datetime", "sql": "SELECT c_time - c_time AS v FROM t", "type": "interval"}, + {"id": "datetime: c_date + c_time", "category": "datetime", "sql": "SELECT c_date + c_time AS v FROM t", "type": "timestamp without time zone"}, + {"id": "datetime: c_interval + c_interval", "category": "datetime", "sql": "SELECT c_interval + c_interval AS v FROM t", "type": "interval"}, + {"id": "datetime: c_interval * 2", "category": "datetime", "sql": "SELECT c_interval * 2 AS v FROM t", "type": "interval"}, + {"id": "datetime: c_interval / 2", "category": "datetime", "sql": "SELECT c_interval / 2 AS v FROM t", "type": "interval"}, + {"id": "datetime: -c_interval", "category": "datetime", "sql": "SELECT -c_interval AS v FROM t", "type": "interval"}, + {"id": "datetime: INTERVAL '1 day'", "category": "datetime", "sql": "SELECT INTERVAL '1 day' AS v FROM t", "type": "interval"}, + {"id": "datetime: c_timestamp - c_date", "category": "datetime", "sql": "SELECT c_timestamp - c_date AS v FROM t", "type": "interval"}, + {"id": "cast: CAST('1' AS SMALLINT)", "category": "cast", "sql": "SELECT CAST('1' AS SMALLINT) AS v FROM t", "type": "smallint"}, + {"id": "cast: CAST('1' AS INTEGER)", "category": "cast", "sql": "SELECT CAST('1' AS INTEGER) AS v FROM t", "type": "integer"}, + {"id": "cast: CAST('1' AS INT)", "category": "cast", "sql": "SELECT CAST('1' AS INT) AS v FROM t", "type": "integer"}, + {"id": "cast: CAST('1' AS BIGINT)", "category": "cast", "sql": "SELECT CAST('1' AS BIGINT) AS v FROM t", "type": "bigint"}, + {"id": "cast: CAST('1' AS NUMERIC)", "category": "cast", "sql": "SELECT CAST('1' AS NUMERIC) AS v FROM t", "type": "numeric"}, + {"id": "cast: CAST('1' AS NUMERIC(10,2))", "category": "cast", "sql": "SELECT CAST('1' AS NUMERIC(10,2)) AS v FROM t", "type": "numeric(10,2)"}, + {"id": "cast: CAST('1' AS DECIMAL(12,4))", "category": "cast", "sql": "SELECT CAST('1' AS DECIMAL(12,4)) AS v FROM t", "type": "numeric(12,4)"}, + {"id": "cast: CAST('1' AS REAL)", "category": "cast", "sql": "SELECT CAST('1' AS REAL) AS v FROM t", "type": "real"}, + {"id": "cast: CAST('1' AS DOUBLE PRECISION)", "category": "cast", "sql": "SELECT CAST('1' AS DOUBLE PRECISION) AS v FROM t", "type": "double precision"}, + {"id": "cast: CAST('1' AS FLOAT)", "category": "cast", "sql": "SELECT CAST('1' AS FLOAT) AS v FROM t", "type": "double precision"}, + {"id": "cast: CAST('1' AS TEXT)", "category": "cast", "sql": "SELECT CAST('1' AS TEXT) AS v FROM t", "type": "text"}, + {"id": "cast: CAST('1' AS VARCHAR)", "category": "cast", "sql": "SELECT CAST('1' AS VARCHAR) AS v FROM t", "type": "character varying"}, + {"id": "cast: CAST('1' AS VARCHAR(10))", "category": "cast", "sql": "SELECT CAST('1' AS VARCHAR(10)) AS v FROM t", "type": "character varying(10)"}, + {"id": "cast: CAST('1' AS CHAR(3))", "category": "cast", "sql": "SELECT CAST('1' AS CHAR(3)) AS v FROM t", "type": "character(3)"}, + {"id": "cast: CAST('true' AS BOOLEAN)", "category": "cast", "sql": "SELECT CAST('true' AS BOOLEAN) AS v FROM t", "type": "boolean"}, + {"id": "cast: CAST('2026-01-02' AS DATE)", "category": "cast", "sql": "SELECT CAST('2026-01-02' AS DATE) AS v FROM t", "type": "date"}, + {"id": "cast: CAST('2026-01-02' AS TIMESTAMP)", "category": "cast", "sql": "SELECT CAST('2026-01-02' AS TIMESTAMP) AS v FROM t", "type": "timestamp without time zone"}, + {"id": "cast: CAST('2026-01-02' AS TIMESTAMPTZ)", "category": "cast", "sql": "SELECT CAST('2026-01-02' AS TIMESTAMPTZ) AS v FROM t", "type": "timestamp with time zone"}, + {"id": "cast: CAST('03:04:05' AS TIME)", "category": "cast", "sql": "SELECT CAST('03:04:05' AS TIME) AS v FROM t", "type": "time without time zone"}, + {"id": "cast: CAST('1 day' AS INTERVAL)", "category": "cast", "sql": "SELECT CAST('1 day' AS INTERVAL) AS v FROM t", "type": "interval"}, + {"id": "cast: CAST('abc' AS BYTEA)", "category": "cast", "sql": "SELECT CAST('abc' AS BYTEA) AS v FROM t", "type": "bytea"}, + {"id": "cast: CAST('00000000-0000-0000-0000-000000000000' AS UUID)", "category": "cast", "sql": "SELECT CAST('00000000-0000-0000-0000-000000000000' AS UUID) AS v FROM t", "type": "uuid"}, + {"id": "cast: CAST('{}' AS JSON)", "category": "cast", "sql": "SELECT CAST('{}' AS JSON) AS v FROM t", "type": "json"}, + {"id": "cast: CAST('{}' AS JSONB)", "category": "cast", "sql": "SELECT CAST('{}' AS JSONB) AS v FROM t", "type": "jsonb"}, + {"id": "cast: c_integer::BIGINT", "category": "cast", "sql": "SELECT c_integer::BIGINT AS v FROM t", "type": "bigint"}, + {"id": "cast: CAST(c_integer AS TEXT)", "category": "cast", "sql": "SELECT CAST(c_integer AS TEXT) AS v FROM t", "type": "text"}, + {"id": "scalar: ROUND(c_smallint)", "category": "scalar", "sql": "SELECT ROUND(c_smallint) AS v FROM t", "type": "double precision"}, + {"id": "scalar: ROUND(c_integer)", "category": "scalar", "sql": "SELECT ROUND(c_integer) AS v FROM t", "type": "double precision"}, + {"id": "scalar: ROUND(c_bigint)", "category": "scalar", "sql": "SELECT ROUND(c_bigint) AS v FROM t", "type": "double precision"}, + {"id": "scalar: ROUND(c_num10_2)", "category": "scalar", "sql": "SELECT ROUND(c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ROUND(c_num20_5)", "category": "scalar", "sql": "SELECT ROUND(c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ROUND(c_numeric)", "category": "scalar", "sql": "SELECT ROUND(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ROUND(c_real)", "category": "scalar", "sql": "SELECT ROUND(c_real) AS v FROM t", "type": "double precision"}, + {"id": "scalar: ROUND(c_double)", "category": "scalar", "sql": "SELECT ROUND(c_double) AS v FROM t", "type": "double precision"}, + {"id": "scalar: ABS(c_smallint)", "category": "scalar", "sql": "SELECT ABS(c_smallint) AS v FROM t", "type": "smallint"}, + {"id": "scalar: ABS(c_integer)", "category": "scalar", "sql": "SELECT ABS(c_integer) AS v FROM t", "type": "integer"}, + {"id": "scalar: ABS(c_bigint)", "category": "scalar", "sql": "SELECT ABS(c_bigint) AS v FROM t", "type": "bigint"}, + {"id": "scalar: ABS(c_num10_2)", "category": "scalar", "sql": "SELECT ABS(c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ABS(c_num20_5)", "category": "scalar", "sql": "SELECT ABS(c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ABS(c_numeric)", "category": "scalar", "sql": "SELECT ABS(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ABS(c_real)", "category": "scalar", "sql": "SELECT ABS(c_real) AS v FROM t", "type": "real"}, + {"id": "scalar: ABS(c_double)", "category": "scalar", "sql": "SELECT ABS(c_double) AS v FROM t", "type": "double precision"}, + {"id": "scalar: FLOOR(c_smallint)", "category": "scalar", "sql": "SELECT FLOOR(c_smallint) AS v FROM t", "type": "double precision"}, + {"id": "scalar: FLOOR(c_integer)", "category": "scalar", "sql": "SELECT FLOOR(c_integer) AS v FROM t", "type": "double precision"}, + {"id": "scalar: FLOOR(c_bigint)", "category": "scalar", "sql": "SELECT FLOOR(c_bigint) AS v FROM t", "type": "double precision"}, + {"id": "scalar: FLOOR(c_num10_2)", "category": "scalar", "sql": "SELECT FLOOR(c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: FLOOR(c_num20_5)", "category": "scalar", "sql": "SELECT FLOOR(c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "scalar: FLOOR(c_numeric)", "category": "scalar", "sql": "SELECT FLOOR(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "scalar: FLOOR(c_real)", "category": "scalar", "sql": "SELECT FLOOR(c_real) AS v FROM t", "type": "double precision"}, + {"id": "scalar: FLOOR(c_double)", "category": "scalar", "sql": "SELECT FLOOR(c_double) AS v FROM t", "type": "double precision"}, + {"id": "scalar: CEIL(c_smallint)", "category": "scalar", "sql": "SELECT CEIL(c_smallint) AS v FROM t", "type": "double precision"}, + {"id": "scalar: CEIL(c_integer)", "category": "scalar", "sql": "SELECT CEIL(c_integer) AS v FROM t", "type": "double precision"}, + {"id": "scalar: CEIL(c_bigint)", "category": "scalar", "sql": "SELECT CEIL(c_bigint) AS v FROM t", "type": "double precision"}, + {"id": "scalar: CEIL(c_num10_2)", "category": "scalar", "sql": "SELECT CEIL(c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: CEIL(c_num20_5)", "category": "scalar", "sql": "SELECT CEIL(c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "scalar: CEIL(c_numeric)", "category": "scalar", "sql": "SELECT CEIL(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "scalar: CEIL(c_real)", "category": "scalar", "sql": "SELECT CEIL(c_real) AS v FROM t", "type": "double precision"}, + {"id": "scalar: CEIL(c_double)", "category": "scalar", "sql": "SELECT CEIL(c_double) AS v FROM t", "type": "double precision"}, + {"id": "scalar: SIGN(c_smallint)", "category": "scalar", "sql": "SELECT SIGN(c_smallint) AS v FROM t", "type": "double precision"}, + {"id": "scalar: SIGN(c_integer)", "category": "scalar", "sql": "SELECT SIGN(c_integer) AS v FROM t", "type": "double precision"}, + {"id": "scalar: SIGN(c_bigint)", "category": "scalar", "sql": "SELECT SIGN(c_bigint) AS v FROM t", "type": "double precision"}, + {"id": "scalar: SIGN(c_num10_2)", "category": "scalar", "sql": "SELECT SIGN(c_num10_2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: SIGN(c_num20_5)", "category": "scalar", "sql": "SELECT SIGN(c_num20_5) AS v FROM t", "type": "numeric"}, + {"id": "scalar: SIGN(c_numeric)", "category": "scalar", "sql": "SELECT SIGN(c_numeric) AS v FROM t", "type": "numeric"}, + {"id": "scalar: SIGN(c_real)", "category": "scalar", "sql": "SELECT SIGN(c_real) AS v FROM t", "type": "double precision"}, + {"id": "scalar: SIGN(c_double)", "category": "scalar", "sql": "SELECT SIGN(c_double) AS v FROM t", "type": "double precision"}, + {"id": "scalar: ROUND(c_smallint, 2)", "category": "scalar", "sql": "SELECT ROUND(c_smallint, 2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ROUND(c_integer, 2)", "category": "scalar", "sql": "SELECT ROUND(c_integer, 2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ROUND(c_bigint, 2)", "category": "scalar", "sql": "SELECT ROUND(c_bigint, 2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ROUND(c_num10_2, 2)", "category": "scalar", "sql": "SELECT ROUND(c_num10_2, 2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ROUND(c_num20_5, 2)", "category": "scalar", "sql": "SELECT ROUND(c_num20_5, 2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ROUND(c_numeric, 2)", "category": "scalar", "sql": "SELECT ROUND(c_numeric, 2) AS v FROM t", "type": "numeric"}, + {"id": "scalar: ROUND(c_real, 2)", "category": "scalar", "sql": "SELECT ROUND(c_real, 2) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "scalar: ROUND(c_double, 2)", "category": "scalar", "sql": "SELECT ROUND(c_double, 2) AS v FROM t", "error": "UndefinedFunction"}, + {"id": "scalar: LENGTH(c_text)", "category": "scalar", "sql": "SELECT LENGTH(c_text) AS v FROM t", "type": "integer"}, + {"id": "scalar: CHAR_LENGTH(c_text)", "category": "scalar", "sql": "SELECT CHAR_LENGTH(c_text) AS v FROM t", "type": "integer"}, + {"id": "scalar: SUBSTRING(c_text, 1, 2)", "category": "scalar", "sql": "SELECT SUBSTRING(c_text, 1, 2) AS v FROM t", "type": "text"}, + {"id": "scalar: SUBSTR(c_text, 1, 2)", "category": "scalar", "sql": "SELECT SUBSTR(c_text, 1, 2) AS v FROM t", "type": "text"}, + {"id": "scalar: UPPER(c_text)", "category": "scalar", "sql": "SELECT UPPER(c_text) AS v FROM t", "type": "text"}, + {"id": "scalar: LOWER(c_text)", "category": "scalar", "sql": "SELECT LOWER(c_text) AS v FROM t", "type": "text"}, + {"id": "scalar: TRIM(c_text)", "category": "scalar", "sql": "SELECT TRIM(c_text) AS v FROM t", "type": "text"}, + {"id": "scalar: REPLACE(c_text, 'a', 'b')", "category": "scalar", "sql": "SELECT REPLACE(c_text, 'a', 'b') AS v FROM t", "type": "text"}, + {"id": "scalar: LEFT(c_text, 2)", "category": "scalar", "sql": "SELECT LEFT(c_text, 2) AS v FROM t", "type": "text"}, + {"id": "scalar: POSITION('a' IN c_text)", "category": "scalar", "sql": "SELECT POSITION('a' IN c_text) AS v FROM t", "type": "integer"}, + {"id": "scalar: DATE_TRUNC('month', c_date)", "category": "scalar", "sql": "SELECT DATE_TRUNC('month', c_date) AS v FROM t", "type": "timestamp with time zone"}, + {"id": "scalar: DATE_TRUNC('month', c_timestamp)", "category": "scalar", "sql": "SELECT DATE_TRUNC('month', c_timestamp) AS v FROM t", "type": "timestamp without time zone"}, + {"id": "scalar: DATE_TRUNC('month', c_timestamptz)", "category": "scalar", "sql": "SELECT DATE_TRUNC('month', c_timestamptz) AS v FROM t", "type": "timestamp with time zone"}, + {"id": "scalar: EXTRACT(YEAR FROM c_date)", "category": "scalar", "sql": "SELECT EXTRACT(YEAR FROM c_date) AS v FROM t", "type": "numeric"}, + {"id": "scalar: EXTRACT(YEAR FROM c_timestamp)", "category": "scalar", "sql": "SELECT EXTRACT(YEAR FROM c_timestamp) AS v FROM t", "type": "numeric"}, + {"id": "scalar: EXTRACT(EPOCH FROM c_timestamp)", "category": "scalar", "sql": "SELECT EXTRACT(EPOCH FROM c_timestamp) AS v FROM t", "type": "numeric"}, + {"id": "scalar: EXTRACT(DOW FROM c_date)", "category": "scalar", "sql": "SELECT EXTRACT(DOW FROM c_date) AS v FROM t", "type": "numeric"}, + {"id": "scalar: DATE_PART('year', c_date)", "category": "scalar", "sql": "SELECT DATE_PART('year', c_date) AS v FROM t", "type": "double precision"}, + {"id": "scalar: NOW()", "category": "scalar", "sql": "SELECT NOW() AS v FROM t", "type": "timestamp with time zone"}, + {"id": "scalar: SQRT(c_double)", "category": "scalar", "sql": "SELECT SQRT(c_double) AS v FROM t", "type": "double precision"}, + {"id": "scalar: POWER(c_integer, 2)", "category": "scalar", "sql": "SELECT POWER(c_integer, 2) AS v FROM t", "type": "double precision"}, + {"id": "scalar: LN(c_double)", "category": "scalar", "sql": "SELECT LN(c_double) AS v FROM t", "type": "double precision"}, + {"id": "scalar: EXP(c_integer)", "category": "scalar", "sql": "SELECT EXP(c_integer) AS v FROM t", "type": "double precision"}, + {"id": "scalar: MOD(c_integer, 2)", "category": "scalar", "sql": "SELECT MOD(c_integer, 2) AS v FROM t", "type": "integer"}, + {"id": "scalar: GREATEST(c_integer, c_bigint)", "category": "scalar", "sql": "SELECT GREATEST(c_integer, c_bigint) AS v FROM t", "type": "bigint"}, + {"id": "scalar: LEAST(c_integer, c_double)", "category": "scalar", "sql": "SELECT LEAST(c_integer, c_double) AS v FROM t", "type": "double precision"}, + {"id": "scalar: RANDOM()", "category": "scalar", "sql": "SELECT RANDOM() AS v FROM t", "type": "double precision"}, + {"id": "scalar: MD5(c_text)", "category": "scalar", "sql": "SELECT MD5(c_text) AS v FROM t", "type": "text"}, + {"id": "scalar: ROW_NUMBER() OVER (ORDER BY c_integer)", "category": "scalar", "sql": "SELECT ROW_NUMBER() OVER (ORDER BY c_integer) AS v FROM t", "type": "bigint"}, + {"id": "scalar: RANK() OVER (ORDER BY c_integer)", "category": "scalar", "sql": "SELECT RANK() OVER (ORDER BY c_integer) AS v FROM t", "type": "bigint"}, + {"id": "scalar: LAG(c_integer) OVER (ORDER BY c_integer)", "category": "scalar", "sql": "SELECT LAG(c_integer) OVER (ORDER BY c_integer) AS v FROM t", "type": "integer"}, + {"id": "scalar: SUM(c_integer) OVER ()", "category": "scalar", "sql": "SELECT SUM(c_integer) OVER () AS v FROM t", "type": "bigint"}, + {"id": "scalar: COUNT(*) OVER ()", "category": "scalar", "sql": "SELECT COUNT(*) OVER () AS v FROM t", "type": "bigint"}, + {"id": "scalar: CURRENT_DATABASE()", "category": "scalar", "sql": "SELECT CURRENT_DATABASE() AS v FROM t", "type": "name"}, + {"id": "scalar: GEN_RANDOM_UUID()", "category": "scalar", "sql": "SELECT GEN_RANDOM_UUID() AS v FROM t", "type": "uuid"}, + {"id": "scalar: TO_CHAR(c_date, 'YYYY')", "category": "scalar", "sql": "SELECT TO_CHAR(c_date, 'YYYY') AS v FROM t", "type": "text"}, + {"id": "scalar: AGE(c_timestamp)", "category": "scalar", "sql": "SELECT AGE(c_timestamp) AS v FROM t", "type": "interval"}, + {"id": "scalar: CLOCK_TIMESTAMP()", "category": "scalar", "sql": "SELECT CLOCK_TIMESTAMP() AS v FROM t", "type": "timestamp with time zone"}, + {"id": "scalar: STATEMENT_TIMESTAMP()", "category": "scalar", "sql": "SELECT STATEMENT_TIMESTAMP() AS v FROM t", "type": "timestamp with time zone"}, + {"id": "niladic: USER", "category": "niladic", "sql": "SELECT USER AS v FROM t", "type": "name"}, + {"id": "niladic: USER without FROM", "category": "niladic", "sql": "SELECT USER AS v", "type": "name"}, + {"id": "niladic: USER in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE USER IS NOT NULL", "type": "integer"}, + {"id": "niladic: CURRENT_USER", "category": "niladic", "sql": "SELECT CURRENT_USER AS v FROM t", "type": "name"}, + {"id": "niladic: CURRENT_USER without FROM", "category": "niladic", "sql": "SELECT CURRENT_USER AS v", "type": "name"}, + {"id": "niladic: CURRENT_USER in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_USER IS NOT NULL", "type": "integer"}, + {"id": "niladic: SESSION_USER", "category": "niladic", "sql": "SELECT SESSION_USER AS v FROM t", "type": "name"}, + {"id": "niladic: SESSION_USER without FROM", "category": "niladic", "sql": "SELECT SESSION_USER AS v", "type": "name"}, + {"id": "niladic: SESSION_USER in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE SESSION_USER IS NOT NULL", "type": "integer"}, + {"id": "niladic: CURRENT_ROLE", "category": "niladic", "sql": "SELECT CURRENT_ROLE AS v FROM t", "type": "name"}, + {"id": "niladic: CURRENT_ROLE without FROM", "category": "niladic", "sql": "SELECT CURRENT_ROLE AS v", "type": "name"}, + {"id": "niladic: CURRENT_ROLE in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_ROLE IS NOT NULL", "type": "integer"}, + {"id": "niladic: CURRENT_SCHEMA", "category": "niladic", "sql": "SELECT CURRENT_SCHEMA AS v FROM t", "type": "name"}, + {"id": "niladic: CURRENT_SCHEMA without FROM", "category": "niladic", "sql": "SELECT CURRENT_SCHEMA AS v", "type": "name"}, + {"id": "niladic: CURRENT_SCHEMA in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_SCHEMA IS NOT NULL", "type": "integer"}, + {"id": "niladic: CURRENT_CATALOG", "category": "niladic", "sql": "SELECT CURRENT_CATALOG AS v FROM t", "type": "name"}, + {"id": "niladic: CURRENT_CATALOG without FROM", "category": "niladic", "sql": "SELECT CURRENT_CATALOG AS v", "type": "name"}, + {"id": "niladic: CURRENT_CATALOG in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_CATALOG IS NOT NULL", "type": "integer"}, + {"id": "niladic: CURRENT_DATE", "category": "niladic", "sql": "SELECT CURRENT_DATE AS v FROM t", "type": "date"}, + {"id": "niladic: CURRENT_DATE without FROM", "category": "niladic", "sql": "SELECT CURRENT_DATE AS v", "type": "date"}, + {"id": "niladic: CURRENT_DATE in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_DATE IS NOT NULL", "type": "integer"}, + {"id": "niladic: CURRENT_TIME", "category": "niladic", "sql": "SELECT CURRENT_TIME AS v FROM t", "type": "time with time zone"}, + {"id": "niladic: CURRENT_TIME without FROM", "category": "niladic", "sql": "SELECT CURRENT_TIME AS v", "type": "time with time zone"}, + {"id": "niladic: CURRENT_TIME in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_TIME IS NOT NULL", "type": "integer"}, + {"id": "niladic: CURRENT_TIMESTAMP", "category": "niladic", "sql": "SELECT CURRENT_TIMESTAMP AS v FROM t", "type": "timestamp with time zone"}, + {"id": "niladic: CURRENT_TIMESTAMP without FROM", "category": "niladic", "sql": "SELECT CURRENT_TIMESTAMP AS v", "type": "timestamp with time zone"}, + {"id": "niladic: CURRENT_TIMESTAMP in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE CURRENT_TIMESTAMP IS NOT NULL", "type": "integer"}, + {"id": "niladic: LOCALTIME", "category": "niladic", "sql": "SELECT LOCALTIME AS v FROM t", "type": "time without time zone"}, + {"id": "niladic: LOCALTIME without FROM", "category": "niladic", "sql": "SELECT LOCALTIME AS v", "type": "time without time zone"}, + {"id": "niladic: LOCALTIME in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE LOCALTIME IS NOT NULL", "type": "integer"}, + {"id": "niladic: LOCALTIMESTAMP", "category": "niladic", "sql": "SELECT LOCALTIMESTAMP AS v FROM t", "type": "timestamp without time zone"}, + {"id": "niladic: LOCALTIMESTAMP without FROM", "category": "niladic", "sql": "SELECT LOCALTIMESTAMP AS v", "type": "timestamp without time zone"}, + {"id": "niladic: LOCALTIMESTAMP in WHERE", "category": "niladic", "sql": "SELECT c_integer AS v FROM t WHERE LOCALTIMESTAMP IS NOT NULL", "type": "integer"} + ] +} diff --git a/crates/polyglot-sql/tests/query_analysis.rs b/crates/polyglot-sql/tests/query_analysis.rs index b92abbdd..8e0ef230 100644 --- a/crates/polyglot-sql/tests/query_analysis.rs +++ b/crates/polyglot-sql/tests/query_analysis.rs @@ -360,7 +360,7 @@ complexity_guard: None, fn analyze_query_infers_the_selected_expression_not_an_arbitrary_upstream_cast() { for (sql, expected) in [ ("WITH a AS (SELECT CAST('1' AS INT) AS n), b AS (SELECT CAST(n AS VARCHAR) AS n FROM a) SELECT n FROM b", "TEXT"), - ("WITH a AS (SELECT CAST('1' AS INT) AS n), b AS (SELECT n + 0.5 AS n FROM a) SELECT n FROM b", "DOUBLE"), + ("WITH a AS (SELECT CAST('1' AS INT) AS n), b AS (SELECT n + 0.5 AS n FROM a) SELECT n FROM b", "DECIMAL(12, 1)"), ("WITH a AS (SELECT CAST('1' AS INT) AS n), b AS (WITH a AS (SELECT CAST('2024-01-01' AS DATE) AS n) SELECT n FROM a) SELECT n FROM b", "DATE"), ("WITH a AS (SELECT CAST('1' AS INT) AS n), b AS (SELECT n FROM a UNION ALL SELECT n FROM a) SELECT n FROM b", "INT"), ] { diff --git a/tools/engine-type-truth/generate.py b/tools/engine-type-truth/generate.py new file mode 100644 index 00000000..a39a1965 --- /dev/null +++ b/tools/engine-type-truth/generate.py @@ -0,0 +1,380 @@ +# /// script +# requires-python = ">=3.10" +# dependencies = ["duckdb==1.5.2", "psycopg[binary]>=3.2"] +# /// +"""Record DuckDB and PostgreSQL result types for a synthetic expression matrix. + +Each case is bound by the real engine against a one-row synthetic table `t`. +DuckDB types come from DESCRIBE (cross-checked with typeof()); PostgreSQL types +come from a temporary view's column type (cross-checked with pg_typeof()), so +declared numeric typmods are retained. Expressions the engine rejects are kept +with their error class so replays can confirm they are skipped deliberately. + +Usage: + docker run -d --rm --name pg-type-truth -e POSTGRES_PASSWORD=pw -p 55432:5432 postgres:17 + uv run tools/engine-type-truth/generate.py --postgres-dsn postgresql://postgres:pw@localhost:55432/postgres +""" + +from __future__ import annotations + +import argparse +import json +import pathlib +from itertools import product + +OUT_DIR = pathlib.Path(__file__).resolve().parents[2] / "crates/polyglot-sql/tests/fixtures/engine_types" + +# (column name, DuckDB type, sample literal) +DUCKDB_COLUMNS = [ + ("c_tinyint", "TINYINT", "1"), + ("c_smallint", "SMALLINT", "2"), + ("c_integer", "INTEGER", "3"), + ("c_bigint", "BIGINT", "4"), + ("c_hugeint", "HUGEINT", "5"), + ("c_utinyint", "UTINYINT", "6"), + ("c_usmallint", "USMALLINT", "7"), + ("c_uinteger", "UINTEGER", "8"), + ("c_ubigint", "UBIGINT", "9"), + ("c_uhugeint", "UHUGEINT", "10"), + ("c_dec4_1", "DECIMAL(4,1)", "1.5"), + ("c_dec9_2", "DECIMAL(9,2)", "2.25"), + ("c_dec18_4", "DECIMAL(18,4)", "3.125"), + ("c_dec38_10", "DECIMAL(38,10)", "4.5"), + ("c_real", "REAL", "1.5"), + ("c_double", "DOUBLE", "2.5"), + ("c_varchar", "VARCHAR", "'abc'"), + ("c_boolean", "BOOLEAN", "TRUE"), + ("c_date", "DATE", "DATE '2026-01-02'"), + ("c_timestamp", "TIMESTAMP", "TIMESTAMP '2026-01-02 03:04:05'"), + ("c_timestamptz", "TIMESTAMPTZ", "TIMESTAMPTZ '2026-01-02 03:04:05+00'"), + ("c_time", "TIME", "TIME '03:04:05'"), + ("c_interval", "INTERVAL", "INTERVAL 1 DAY"), +] + +POSTGRES_COLUMNS = [ + ("c_smallint", "smallint", "1"), + ("c_integer", "integer", "2"), + ("c_bigint", "bigint", "3"), + ("c_num10_2", "numeric(10,2)", "1.25"), + ("c_num20_5", "numeric(20,5)", "2.5"), + ("c_numeric", "numeric", "3.75"), + ("c_real", "real", "1.5"), + ("c_double", "double precision", "2.5"), + ("c_text", "text", "'abc'"), + ("c_varchar", "varchar(20)", "'def'"), + ("c_boolean", "boolean", "true"), + ("c_date", "date", "DATE '2026-01-02'"), + ("c_timestamp", "timestamp", "TIMESTAMP '2026-01-02 03:04:05'"), + ("c_timestamptz", "timestamptz", "TIMESTAMPTZ '2026-01-02 03:04:05+00'"), + ("c_time", "time", "TIME '03:04:05'"), + ("c_interval", "interval", "INTERVAL '1 day'"), +] + +DUCKDB_NUMERIC = [c for c, _, _ in DUCKDB_COLUMNS[:16]] +POSTGRES_NUMERIC = [c for c, _, _ in POSTGRES_COLUMNS[:8]] + + +def expression_cases(dialect: str) -> list[tuple[str, str, str]]: + """Return (id, category, sql) triples.""" + duck = dialect == "duckdb" + numeric = DUCKDB_NUMERIC if duck else POSTGRES_NUMERIC + text = "c_varchar" if duck else "c_text" + cases: list[tuple[str, str, str]] = [] + + def add(category: str, expr: str, sql: str | None = None) -> None: + cases.append((f"{category}: {expr}", category, sql or f"SELECT {expr} AS v FROM t")) + + ops = ["+", "-", "*", "/", "%"] + (["//"] if duck else []) + for op, left, right in product(ops, numeric, numeric): + add("arithmetic", f"{left} {op} {right}") + literals = ["7", "2", "3000000000", "1.5", "2.25", "1e3"] + for op, left, right in product(ops, literals, literals): + add("arithmetic_literal", f"{left} {op} {right}") + for op, column, literal in product(ops, ["c_integer", "c_bigint", numeric[-3], numeric[-1]], ["2", "1.5"]): + add("arithmetic_literal", f"{column} {op} {literal}") + add("arithmetic_literal", "SUM(c_integer) / COUNT(*)") + add("arithmetic_literal", "-c_integer") + add("arithmetic_literal", "-c_double") + for column in numeric: + add("arithmetic_literal", f"-{column}") + + for left, right in [ + (text, text), + (text, "c_integer"), + (text, "c_date"), + ("'a'", "'b'"), + ("'a'", text), + (text, "c_boolean"), + (text, numeric[-1]), + ] + ([("c_integer", "c_integer")] if duck else [("c_varchar", "c_varchar"), (text, "c_varchar")]): + add("concat", f"{left} || {right}") + add("concat", f"CONCAT({text}, c_integer)") + add("concat", f"CONCAT({text}, {text})") + add("concat", f"CONCAT_WS(',', {text}, c_integer)") + + for expr in [ + "c_integer = c_bigint", + "c_integer < c_double", + f"{text} <> 'x'", + "c_date >= c_timestamp", + "c_boolean AND c_integer > 1", + "c_boolean OR c_boolean", + "NOT c_boolean", + "c_integer IS NULL", + "c_integer IS NOT NULL", + "c_integer BETWEEN 1 AND 3", + "c_integer IN (1, 2)", + f"{text} LIKE 'a%'", + f"{text} ILIKE 'a%'", + f"{text} NOT LIKE 'a%'", + "c_boolean IS TRUE", + "c_integer IS DISTINCT FROM c_bigint", + "EXISTS (SELECT 1)", + ]: + add("comparison", expr) + + aggregate_inputs = numeric + [text, "c_boolean", "c_date", "c_timestamp", "c_interval"] + for function, column in product(["SUM", "AVG", "MIN", "MAX", "COUNT", "STDDEV"], aggregate_inputs): + add("aggregate", f"{function}({column})") + add("aggregate", "COUNT(*)") + for function in ["VARIANCE", "STDDEV_POP", "VAR_POP"]: + for column in ["c_integer", numeric[-3], "c_double"]: + add("aggregate", f"{function}({column})") + for function in ["BOOL_AND", "BOOL_OR"]: + add("aggregate", f"{function}(c_boolean)") + add("aggregate", f"STRING_AGG({text}, ',')") + + unify = ( + ["c_smallint", "c_integer", "c_bigint", numeric[3] if duck else "c_num10_2"] + + ([numeric[10], numeric[11]] if duck else ["c_num20_5", "c_numeric"]) + + ["c_real", "c_double", text, "c_date", "c_timestamp"] + ) + for left, right in product(unify, unify): + add("conditional", f"CASE WHEN c_boolean THEN {left} ELSE {right} END") + add("conditional", f"COALESCE({left}, {right})") + if left == right or (left in numeric and right in numeric): + add("conditional", f"NULLIF({left}, {right})") + if duck: + add("conditional", f"IFNULL({left}, {right})") + for literal in ["1", "1.5", "'x'", "NULL"]: + add("conditional", f"COALESCE(c_integer, {literal})") + add("conditional", f"CASE WHEN c_boolean THEN c_integer ELSE {literal} END") + add("conditional", "CASE WHEN c_boolean THEN 1 END") + add("conditional", "CASE WHEN c_boolean THEN 1 ELSE 2.5 END") + + for left, right in product(unify, unify): + add( + "set_operation", + f"{left} UNION ALL {right}", + f"SELECT {left} AS v FROM t UNION ALL SELECT {right} AS v FROM t", + ) + for left, right in [("1", "2.5"), ("1", "3000000000"), ("'a'", "'bc'"), ("NULL", "c_integer")]: + add( + "set_operation", + f"{left} UNION ALL {right}", + f"SELECT {left} AS v FROM t UNION ALL SELECT {right} AS v FROM t", + ) + + interval = "INTERVAL 1 DAY" if duck else "INTERVAL '1 day'" + for expr in [ + "c_date + 1", + "1 + c_date", + "c_date - 1", + "c_date - c_date", + f"c_date + {interval}", + f"c_date - {interval}", + f"c_timestamp + {interval}", + f"c_timestamp - {interval}", + f"c_timestamptz + {interval}", + "c_timestamp - c_timestamp", + "c_timestamptz - c_timestamptz", + "c_date - c_timestamp", + f"c_time + {interval}", + "c_time - c_time", + "c_date + c_time", + "c_interval + c_interval", + "c_interval * 2", + "c_interval / 2", + "-c_interval", + interval, + "c_timestamp - c_date", + ]: + add("datetime", expr) + + casts = ( + ["TINYINT", "SMALLINT", "INTEGER", "BIGINT", "HUGEINT", "UBIGINT", "DECIMAL", "DECIMAL(10,2)", "DECIMAL(5)", + "NUMERIC(12,4)", "REAL", "FLOAT", "DOUBLE", "VARCHAR", "VARCHAR(10)", "TEXT", "BOOLEAN", "DATE", + "TIMESTAMP", "TIMESTAMPTZ", "TIME", "INTERVAL", "BLOB", "UUID", "JSON"] + if duck + else ["SMALLINT", "INTEGER", "INT", "BIGINT", "NUMERIC", "NUMERIC(10,2)", "DECIMAL(12,4)", "REAL", + "DOUBLE PRECISION", "FLOAT", "TEXT", "VARCHAR", "VARCHAR(10)", "CHAR(3)", "BOOLEAN", "DATE", + "TIMESTAMP", "TIMESTAMPTZ", "TIME", "INTERVAL", "BYTEA", "UUID", "JSON", "JSONB"] + ) + for target in casts: + source = "'00000000-0000-0000-0000-000000000000'" if target == "UUID" else ( + "'{}'" if target.startswith("JSON") else ("'1 day'" if target == "INTERVAL" else ( + "'2026-01-02'" if target in {"DATE", "TIMESTAMP", "TIMESTAMPTZ"} else ( + "'03:04:05'" if target == "TIME" else ( + "'abc'" if target in {"BLOB", "BYTEA"} else ( + "'true'" if target == "BOOLEAN" else "'1'")))))) + add("cast", f"CAST({source} AS {target})") + add("cast", "c_integer::BIGINT") + add("cast", f"CAST(c_integer AS {'VARCHAR' if duck else 'TEXT'})") + + for function, column in product(["ROUND", "ABS", "FLOOR", "CEIL", "SIGN"], numeric): + add("scalar", f"{function}({column})") + for column in numeric: + add("scalar", f"ROUND({column}, 2)") + for expr in [ + f"LENGTH({text})", + f"CHAR_LENGTH({text})", + f"SUBSTRING({text}, 1, 2)", + f"SUBSTR({text}, 1, 2)", + f"UPPER({text})", + f"LOWER({text})", + f"TRIM({text})", + f"REPLACE({text}, 'a', 'b')", + f"LEFT({text}, 2)", + f"POSITION('a' IN {text})", + "DATE_TRUNC('month', c_date)", + "DATE_TRUNC('month', c_timestamp)", + "DATE_TRUNC('month', c_timestamptz)", + "EXTRACT(YEAR FROM c_date)", + "EXTRACT(YEAR FROM c_timestamp)", + "EXTRACT(EPOCH FROM c_timestamp)", + "EXTRACT(DOW FROM c_date)", + "DATE_PART('year', c_date)", + "NOW()", + "SQRT(c_double)", + "POWER(c_integer, 2)", + "LN(c_double)", + "EXP(c_integer)", + "MOD(c_integer, 2)", + "GREATEST(c_integer, c_bigint)", + "LEAST(c_integer, c_double)", + "RANDOM()", + f"MD5({text})", + "ROW_NUMBER() OVER (ORDER BY c_integer)", + "RANK() OVER (ORDER BY c_integer)", + "LAG(c_integer) OVER (ORDER BY c_integer)", + "SUM(c_integer) OVER ()", + "COUNT(*) OVER ()", + ]: + add("scalar", expr) + for expr in (["TODAY()", "CURRENT_DATABASE()", "GEN_RANDOM_UUID()", "EPOCH(c_timestamp)", "YEAR(c_date)", + "DAYNAME(c_date)", "STRFTIME(c_date, '%Y')", "LIST_VALUE(1, 2)"] + if duck else ["CURRENT_DATABASE()", "GEN_RANDOM_UUID()", "TO_CHAR(c_date, 'YYYY')", "AGE(c_timestamp)", + "CLOCK_TIMESTAMP()", "STATEMENT_TIMESTAMP()"]): + add("scalar", expr) + + niladic = ["USER", "CURRENT_USER", "SESSION_USER", "CURRENT_ROLE", "CURRENT_SCHEMA", "CURRENT_CATALOG", + "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "LOCALTIME", "LOCALTIMESTAMP"] + for name in niladic: + add("niladic", name) + add("niladic", f"{name} without FROM", f"SELECT {name} AS v") + add("niladic", f"{name} in WHERE", f"SELECT c_integer AS v FROM t WHERE {name} IS NOT NULL") + return cases + + +def table_ddl(columns) -> tuple[str, str]: + ddl = "CREATE TABLE t (" + ", ".join(f"{name} {ty}" for name, ty, _ in columns) + ")" + insert = "INSERT INTO t VALUES (" + ", ".join(value for _, _, value in columns) + ")" + return ddl, insert + + +def error_class(message: str) -> str: + return message.split(":", 1)[0].strip().split("\n")[0][:80] + + +def run_duckdb() -> dict: + import duckdb + + conn = duckdb.connect() + ddl, insert = table_ddl(DUCKDB_COLUMNS) + conn.execute(ddl) + conn.execute(insert) + cases = [] + for case_id, category, sql in expression_cases("duckdb"): + record = {"id": case_id, "category": category, "sql": sql} + try: + described = conn.execute(f"DESCRIBE {sql}").fetchall()[0][1] + runtime = conn.execute(f"SELECT typeof(v) FROM ({sql}) LIMIT 1").fetchall() + if runtime and runtime[0][0] != described: + raise AssertionError(f"{case_id}: DESCRIBE {described} != typeof {runtime[0][0]}") + record["type"] = described + except duckdb.Error as error: + record["error"] = error_class(str(error)) + cases.append(record) + return { + "engine": "duckdb", + "engine_version": duckdb.__version__, + "method": "DESCRIBE of SELECT over one-row synthetic table t, cross-checked with typeof()", + "schema": {"tables": [{"name": "t", "columns": [{"name": n, "type": ty} for n, ty, _ in DUCKDB_COLUMNS]}]}, + "cases": cases, + } + + +def run_postgres(dsn: str) -> dict: + import psycopg + + conn = psycopg.connect(dsn, autocommit=False) + cur = conn.cursor() + cur.execute("DROP TABLE IF EXISTS t") + ddl, insert = table_ddl(POSTGRES_COLUMNS) + cur.execute(ddl) + cur.execute(insert) + cur.execute("SET TIME ZONE 'UTC'") + conn.commit() + cur.execute("SHOW server_version") + version = cur.fetchone()[0] + cases = [] + for case_id, category, sql in expression_cases("postgres"): + record = {"id": case_id, "category": category, "sql": sql} + try: + cur.execute(f"CREATE TEMP VIEW type_probe AS {sql}") + cur.execute( + "SELECT format_type(atttypid, atttypmod) FROM pg_attribute " + "WHERE attrelid = 'type_probe'::regclass AND attnum = 1" + ) + described = cur.fetchone()[0] + cur.execute(f"SELECT pg_typeof(v)::text FROM ({sql}) AS probe LIMIT 1") + row = cur.fetchone() + base = described.split("(")[0] + if row and row[0] != base and not (row[0] == "unknown" and described == "text"): + raise AssertionError(f"{case_id}: view {described} != pg_typeof {row[0]}") + record["type"] = described + except psycopg.Error as error: + record["error"] = type(error).__name__ + conn.rollback() + cases.append(record) + cur.execute("DROP TABLE t") + conn.commit() + return { + "engine": "postgres", + "engine_version": version, + "method": "temporary view column type over one-row synthetic table t, cross-checked with pg_typeof()", + "schema": {"tables": [{"name": "t", "columns": [{"name": n, "type": ty} for n, ty, _ in POSTGRES_COLUMNS]}]}, + "cases": cases, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--postgres-dsn") + args = parser.parse_args() + OUT_DIR.mkdir(parents=True, exist_ok=True) + outputs = {"duckdb": run_duckdb()} + if args.postgres_dsn: + outputs["postgres"] = run_postgres(args.postgres_dsn) + for name, data in outputs.items(): + path = OUT_DIR / f"{name}.json" + records = data.pop("cases") + cases = ",\n".join(" " + json.dumps(case) for case in records) + header = json.dumps(data, indent=1)[:-2] + path.write_text(f'{header},\n "cases": [\n{cases}\n ]\n}}\n') + typed = sum("type" in case for case in records) + print(f"{name}: {len(records)} cases, {typed} typed, {len(records) - typed} engine errors -> {path}") + + +if __name__ == "__main__": + main() From 330ad25be6f3f5e7b2285457da6f6ca56b600dc0 Mon Sep 17 00:00:00 2001 From: Kevin Longe <273747162+kvlonge@users.noreply.github.com> Date: Sat, 26 Sep 2026 21:06:20 +0100 Subject: [PATCH 2/2] chore: bump version to 0.13.4 --- Cargo.lock | 12 ++++++------ Cargo.toml | 2 +- README.md | 2 +- crates/polyglot-sql-function-catalogs/README.md | 2 +- crates/polyglot-sql/Cargo.toml | 4 ++-- crates/polyglot-sql/README.md | 8 ++++---- examples/rust/Cargo.lock | 6 +++--- examples/rust/Cargo.toml | 2 +- packages/documentation/package.json | 2 +- packages/go/README.md | 2 +- packages/go/types.go | 2 +- packages/playground/package.json | 2 +- packages/python-docs/package.json | 2 +- packages/sdk/package.json | 2 +- 14 files changed, 25 insertions(+), 25 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6608b338..3026f1cd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -605,7 +605,7 @@ dependencies = [ [[package]] name = "polyglot-sql" -version = "0.13.3" +version = "0.13.4" dependencies = [ "criterion", "once_cell", @@ -624,7 +624,7 @@ dependencies = [ [[package]] name = "polyglot-sql-ast-derive" -version = "0.13.3" +version = "0.13.4" dependencies = [ "proc-macro2", "quote", @@ -633,7 +633,7 @@ dependencies = [ [[package]] name = "polyglot-sql-ffi" -version = "0.13.3" +version = "0.13.4" dependencies = [ "cbindgen", "polyglot-sql", @@ -643,11 +643,11 @@ dependencies = [ [[package]] name = "polyglot-sql-function-catalogs" -version = "0.13.3" +version = "0.13.4" [[package]] name = "polyglot-sql-python" -version = "0.13.3" +version = "0.13.4" dependencies = [ "polyglot-sql", "pyo3", @@ -658,7 +658,7 @@ dependencies = [ [[package]] name = "polyglot-sql-wasm" -version = "0.13.3" +version = "0.13.4" dependencies = [ "console_error_panic_hook", "js-sys", diff --git a/Cargo.toml b/Cargo.toml index 27bbfc0b..915249b1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,7 +13,7 @@ exclude = [ ] [workspace.package] -version = "0.13.3" +version = "0.13.4" edition = "2021" license = "MIT" authors = ["polyglot contributors"] diff --git a/README.md b/README.md index 585f2147..dacdc4bc 100644 --- a/README.md +++ b/README.md @@ -306,7 +306,7 @@ If you want to disable `stacker` for a native Rust build, turn off default featu ```toml [dependencies] -polyglot-sql = { version = "0.13.3", default-features = false, features = ["all-dialects", "transpile"] } +polyglot-sql = { version = "0.13.4", default-features = false, features = ["all-dialects", "transpile"] } ``` That can reduce overhead slightly on trusted inputs, but you lose the default stack-growth protection for deeply nested SQL. diff --git a/crates/polyglot-sql-function-catalogs/README.md b/crates/polyglot-sql-function-catalogs/README.md index 1a8675a3..566e0c12 100644 --- a/crates/polyglot-sql-function-catalogs/README.md +++ b/crates/polyglot-sql-function-catalogs/README.md @@ -25,7 +25,7 @@ With `polyglot-sql` compile-time wiring (recommended): ```toml [dependencies] -polyglot-sql = { version = "0.13.3", features = ["function-catalog-clickhouse"] } +polyglot-sql = { version = "0.13.4", features = ["function-catalog-clickhouse"] } ``` Then run schema validation with type checks: diff --git a/crates/polyglot-sql/Cargo.toml b/crates/polyglot-sql/Cargo.toml index f30f7275..3b0032ad 100644 --- a/crates/polyglot-sql/Cargo.toml +++ b/crates/polyglot-sql/Cargo.toml @@ -100,14 +100,14 @@ function-catalog-all-dialects = [ [dependencies] regex = { version = "1", optional = true } -polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.3" } +polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.4" } serde = { workspace = true } serde_json = { workspace = true } thiserror = { workspace = true } unicode-segmentation = { workspace = true } stacker = { version = "0.1", optional = true } ts-rs = { version = "12.0", features = ["serde-compat"], optional = true } -polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.13.3", optional = true, default-features = false } +polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.13.4", optional = true, default-features = false } [dev-dependencies] pretty_assertions = "1.4" diff --git a/crates/polyglot-sql/README.md b/crates/polyglot-sql/README.md index 3921fd11..41699924 100644 --- a/crates/polyglot-sql/README.md +++ b/crates/polyglot-sql/README.md @@ -25,12 +25,12 @@ By default, `polyglot-sql` enables the full public API. Parser-only consumers ca disable default features and opt into only the dialect parsers they need: ```toml -polyglot-sql = { version = "0.13.3", default-features = false } +polyglot-sql = { version = "0.13.4", default-features = false } ``` ```toml polyglot-sql = { - version = "0.13.3", + version = "0.13.4", default-features = false, features = ["dialect-clickhouse"], } @@ -44,14 +44,14 @@ Examples: ```toml # Parse and generate SQL for one dialect. polyglot-sql = { - version = "0.13.3", + version = "0.13.4", default-features = false, features = ["generate", "dialect-clickhouse"], } # Cross-dialect transpilation. polyglot-sql = { - version = "0.13.3", + version = "0.13.4", default-features = false, features = ["transpile", "dialect-clickhouse", "dialect-postgresql"], } diff --git a/examples/rust/Cargo.lock b/examples/rust/Cargo.lock index fb16826d..438eecc1 100644 --- a/examples/rust/Cargo.lock +++ b/examples/rust/Cargo.lock @@ -71,7 +71,7 @@ dependencies = [ [[package]] name = "polyglot-sql" -version = "0.13.3" +version = "0.13.4" dependencies = [ "polyglot-sql-ast-derive", "polyglot-sql-function-catalogs", @@ -85,7 +85,7 @@ dependencies = [ [[package]] name = "polyglot-sql-ast-derive" -version = "0.13.3" +version = "0.13.4" dependencies = [ "proc-macro2", "quote", @@ -101,7 +101,7 @@ dependencies = [ [[package]] name = "polyglot-sql-function-catalogs" -version = "0.13.3" +version = "0.13.4" [[package]] name = "proc-macro2" diff --git a/examples/rust/Cargo.toml b/examples/rust/Cargo.toml index fce60de1..bf105a6a 100644 --- a/examples/rust/Cargo.toml +++ b/examples/rust/Cargo.toml @@ -5,4 +5,4 @@ edition = "2021" publish = false [dependencies] -polyglot-sql = { version = "0.13.3", path = "../../crates/polyglot-sql" } +polyglot-sql = { version = "0.13.4", path = "../../crates/polyglot-sql" } diff --git a/packages/documentation/package.json b/packages/documentation/package.json index 63a3c413..0589a945 100644 --- a/packages/documentation/package.json +++ b/packages/documentation/package.json @@ -1,6 +1,6 @@ { "name": "@polyglot-sql/documentation", - "version": "0.13.3", + "version": "0.13.4", "private": true, "type": "module", "scripts": { diff --git a/packages/go/README.md b/packages/go/README.md index 5346f093..98a33531 100644 --- a/packages/go/README.md +++ b/packages/go/README.md @@ -21,7 +21,7 @@ go get github.com/tobilg/polyglot/packages/go ``` Go module releases use nested tags that match the root Polyglot release, for -example `packages/go/v0.13.3`. +example `packages/go/v0.13.4`. ## Native Library Setup diff --git a/packages/go/types.go b/packages/go/types.go index c0cc222c..a46e2973 100644 --- a/packages/go/types.go +++ b/packages/go/types.go @@ -2,7 +2,7 @@ package polyglot import "encoding/json" -const sdkVersion = "0.13.3" +const sdkVersion = "0.13.4" func Version() string { return sdkVersion diff --git a/packages/playground/package.json b/packages/playground/package.json index 4ccbe990..092b7c39 100644 --- a/packages/playground/package.json +++ b/packages/playground/package.json @@ -1,6 +1,6 @@ { "name": "@polyglot-sql/playground", - "version": "0.13.3", + "version": "0.13.4", "private": true, "type": "module", "scripts": { diff --git a/packages/python-docs/package.json b/packages/python-docs/package.json index 0ab7ccb0..fd23fb30 100644 --- a/packages/python-docs/package.json +++ b/packages/python-docs/package.json @@ -1,6 +1,6 @@ { "name": "@polyglot-sql/python-docs", - "version": "0.13.3", + "version": "0.13.4", "private": true, "type": "module", "scripts": { diff --git a/packages/sdk/package.json b/packages/sdk/package.json index bfbf5a35..ff9e75be 100644 --- a/packages/sdk/package.json +++ b/packages/sdk/package.json @@ -1,6 +1,6 @@ { "name": "@polyglot-sql/sdk", - "version": "0.13.3", + "version": "0.13.4", "description": "SQL dialect translator powered by WebAssembly", "type": "module", "main": "./dist/index.cjs",