diff --git a/Cargo.lock b/Cargo.lock index 93e9016bfc..fe44d1874d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4145,6 +4145,7 @@ dependencies = [ "sqlquack-syntax", "sqlquack-syntax-bigquery", "sqlquack-syntax-postgres", + "stacker", ] [[package]] diff --git a/crates/sqlbuild-analysis/Cargo.toml b/crates/sqlbuild-analysis/Cargo.toml index 9a7d4b5a89..3bae24f07f 100644 --- a/crates/sqlbuild-analysis/Cargo.toml +++ b/crates/sqlbuild-analysis/Cargo.toml @@ -29,6 +29,7 @@ sqlclean.workspace = true sqlquack-syntax.workspace = true sqlquack-syntax-bigquery.workspace = true sqlquack-syntax-postgres.workspace = true +stacker.workspace = true [lints] workspace = true diff --git a/crates/sqlbuild-analysis/src/contracts/tests/test_evaluate_model_contracts.rs b/crates/sqlbuild-analysis/src/contracts/tests/test_evaluate_model_contracts.rs index d1a7294798..4573a0010a 100644 --- a/crates/sqlbuild-analysis/src/contracts/tests/test_evaluate_model_contracts.rs +++ b/crates/sqlbuild-analysis/src/contracts/tests/test_evaluate_model_contracts.rs @@ -282,11 +282,11 @@ fn given_models_sharing_types_when_evaluating_together_then_each_matches_its_own } #[test] -fn given_a_dialect_polyglot_does_not_know_when_comparing_types_then_python_error_is_returned() { +fn given_a_dialect_no_adapter_ships_when_comparing_types_then_python_error_is_returned() { let test_cases = [UnknownDialectTestCase { description: "an enforced contract compared under an unknown dialect", - dialect: "motherduck", - expected_error: "Unknown dialect: motherduck", + dialect: "mysql", + expected_error: "Unknown dialect: mysql", }]; for test_case in test_cases { let request = ContractRequest { diff --git a/crates/sqlbuild-analysis/src/planner_strategy/main/classify_cursor_sql_type.rs b/crates/sqlbuild-analysis/src/planner_strategy/main/classify_cursor_sql_type.rs index 22dedf16bd..1636707d0d 100644 --- a/crates/sqlbuild-analysis/src/planner_strategy/main/classify_cursor_sql_type.rs +++ b/crates/sqlbuild-analysis/src/planner_strategy/main/classify_cursor_sql_type.rs @@ -7,9 +7,9 @@ use crate::planner_strategy::_helpers::type_names::{argument, named_type}; use crate::planner_strategy::constants::{GENERIC_DIALECT, POLYGLOT_CUSTOM_TYPE_NAME}; use crate::planner_strategy::errors::TypeParseFailure; use crate::planner_strategy::models::CursorType; -use crate::type_system::main::polyglot_type_args::polyglot_type_args; +use crate::type_system::main::type_args::type_args; -/// Timestamp or integer for supported cross-adapter types; `Err` when Polyglot cannot parse an unknown type. +/// Timestamp or integer for supported cross-adapter types; `Err` when an unknown type does not parse. pub fn classify_cursor_sql_type(sql_type: &str) -> Result, TypeParseFailure> { let normalized: String = sql_type .to_uppercase() @@ -29,7 +29,7 @@ pub fn classify_cursor_sql_type(sql_type: &str) -> Result, Ty return Ok(Some(cursor_type)); } let args: Map = - polyglot_type_args(&normalized, GENERIC_DIALECT).map_err(|message| TypeParseFailure { + type_args(&normalized, GENERIC_DIALECT).map_err(|message| TypeParseFailure { normalized_type: normalized.clone(), message, })?; diff --git a/crates/sqlbuild-analysis/src/semantic_checks/tests/test_metadata.rs b/crates/sqlbuild-analysis/src/semantic_checks/tests/test_metadata.rs index 55c2ed010d..7f5d8d5bb3 100644 --- a/crates/sqlbuild-analysis/src/semantic_checks/tests/test_metadata.rs +++ b/crates/sqlbuild-analysis/src/semantic_checks/tests/test_metadata.rs @@ -17,8 +17,8 @@ fn given_project_metadata_when_checking_then_reports_python_errors() { expected_outcome: Ok(expected_checked_outcome()), }, MetadataTestCase { - description: "a dialect the all-dialects parser build added", - dialect: "mysql", + description: "a shipped dialect without a native type parser", + dialect: "tsql", mart_shape: MART_SHAPE, expected_outcome: Ok(expected_checked_outcome()), }, diff --git a/crates/sqlbuild-analysis/src/type_system/_helpers/mod.rs b/crates/sqlbuild-analysis/src/type_system/_helpers/mod.rs index 70cbe23166..542e409872 100644 --- a/crates/sqlbuild-analysis/src/type_system/_helpers/mod.rs +++ b/crates/sqlbuild-analysis/src/type_system/_helpers/mod.rs @@ -2,4 +2,5 @@ pub(crate) mod dialects; pub(crate) mod fallback; pub(crate) mod parsed; pub(crate) mod python_text; -pub(crate) mod shallow_args; +pub(crate) mod spelling; +pub(crate) mod type_reader; diff --git a/crates/sqlbuild-analysis/src/type_system/_helpers/parsed.rs b/crates/sqlbuild-analysis/src/type_system/_helpers/parsed.rs index 1ee482d2c8..3d2cada562 100644 --- a/crates/sqlbuild-analysis/src/type_system/_helpers/parsed.rs +++ b/crates/sqlbuild-analysis/src/type_system/_helpers/parsed.rs @@ -1,97 +1,121 @@ -//! Python's `_normalize_with_polyglot`: the parsed type's SQL and arguments. +//! A parsed type's normalization: its tag, parameters and dialect spelling. -use polyglot_sql::{ - ComplexityGuardOptions, DataType, Dialect, DialectType, Expression, ParseOptions, -}; -use serde_json::{Map, Value}; +use serde_json::Value; +use sqlquack_syntax::tokens::models::Dialect; use crate::type_system::_helpers::fallback::{ normalize_with_fallback, python_or_default, simple, snowflake_integer, timestamp_normalized_name, }; use crate::type_system::_helpers::python_text::{python_int, split_type_and_params, upper}; -use crate::type_system::_helpers::shallow_args::shallow_args; +use crate::type_system::_helpers::spelling::{SpellingDialect, spell}; +use crate::type_system::_helpers::type_reader::read_type; use crate::type_system::constants::{ BIGNUMERIC_TYPE_NAME, BIGQUERY_STRING_TYPE_NAME, BOOLEAN_TYPE_NAMES, - CUSTOM_NORMALIZATION_TYPE_NAMES, DATE_TYPE_NAME, DATETIME_TYPE_NAME, DECIMAL_TYPE_NAMES, - FLOAT_TYPE_NAMES, FLOAT_WIRE_TYPE_NAME, INTEGER_PARSE_TYPE_NAMES, INTEGER_PRECISION, - INTEGER_SCALE, INTEGER_TYPE_NAMES, MAX_FUNCTION_CALL_DEPTH, POLYGLOT_CUSTOM_TYPE_NAME, - POLYGLOT_TYPE_NAME_ALIASES, SIZED_TEXT_TYPE_NAMES, STRING_TYPE_NAMES, TIMESTAMP_TYPE_NAMES, - UNBOUNDED_TEXT_TYPE_NAMES, VARCHAR_TYPE_NAME, + CUSTOM_NORMALIZATION_TYPE_NAMES, CUSTOM_TYPE_TAG, DATE_TYPE_NAME, DATETIME_TYPE_NAME, + DECIMAL_TYPE_NAMES, FLOAT_TYPE_NAMES, FLOAT_WIRE_TYPE_NAME, INTEGER_PARSE_TYPE_NAMES, + INTEGER_PRECISION, INTEGER_SCALE, INTEGER_TYPE_NAMES, MAX_TYPE_NESTING, SIZED_TEXT_TYPE_NAMES, + STRING_TYPE_NAMES, TIMESTAMP_TYPE_NAMES, TYPE_TAG_ALIASES, UNBOUNDED_TEXT_TYPE_NAMES, + VARCHAR_TYPE_NAME, }; -use crate::type_system::errors::TypeNormalizationError; use crate::type_system::models::{NormalizedType, PythonInteger, TypeDialect, TypeFamily}; +use crate::warehouse_types::main::type_tree::type_tree; +use crate::warehouse_types::models::TypeParser; -/// Parse one type with SQLBuild's Polyglot guard; the error text is what Python logs. -pub(crate) fn parse_type(type_sql: &str, dialect: &Dialect) -> Result { - dialect - .parse_data_type_with_options( - type_sql, - &ParseOptions { - complexity_guard: Some(ComplexityGuardOptions { - max_function_call_depth: Some(MAX_FUNCTION_CALL_DEPTH), - ..Default::default() - }), - }, - ) - .map_err(|error| error.to_string()) +/// The type tree of `type_sql` from SQLQuack's parser, else SQLBuild's reader, or the error. +pub(crate) fn parse_type(type_sql: &str, dialect: SpellingDialect) -> Result { + if nesting_bound(type_sql) > MAX_TYPE_NESTING { + return Err("the type nests too deeply".to_owned()); + } + let parser: TypeParser = match dialect { + SpellingDialect::Snowflake => TypeParser::Core(Dialect::Snowflake), + SpellingDialect::DuckDb => TypeParser::Core(Dialect::DuckDB), + SpellingDialect::Sqlite => TypeParser::Core(Dialect::SQLite), + SpellingDialect::Postgres => TypeParser::Postgres, + SpellingDialect::BigQuery => TypeParser::BigQuery, + SpellingDialect::Generic + | SpellingDialect::Databricks + | SpellingDialect::Tsql + | SpellingDialect::ClickHouse => return read_type(type_sql, dialect), + }; + let native: Result = type_tree(type_sql, parser); + match native { + Ok(tree) if !has_custom(&tree) => Ok(tree), + Ok(tree) => Ok(read_type(type_sql, dialect).unwrap_or(tree)), + Err(error) => read_type(type_sql, dialect).map_err(|_| error), + } } -/// The parsed type's SQL, in generic spelling when the dialect refuses a type it cannot hold. -fn generated_type( - expression: &Expression, - polyglot: &Dialect, -) -> Result { - match polyglot.generate(expression) { - Ok(generated) => Ok(generated), - Err(polyglot_sql::error::Error::Unsupported { .. }) => Dialect::get(DialectType::Generic) - .generate(expression) - .map_err(|error| TypeNormalizationError::Generation(error.to_string())), - Err(error) => Err(TypeNormalizationError::Generation(error.to_string())), +/// A bound on the type tree's depth: the deepest brackets plus the array suffixes. +pub(crate) fn nesting_bound(type_sql: &str) -> usize { + let (mut depth, mut deepest, mut suffixes): (usize, usize, usize) = (0, 0, 0); + for character in type_sql.chars() { + match character { + '(' | '<' => { + depth += 1; + deepest = deepest.max(depth); + } + ')' | '>' => depth = depth.saturating_sub(1), + '[' => suffixes += 1, + _ => {} + } + } + deepest + suffixes +} + +/// Whether `tree` or any type nested in it is an unknown type name. +fn has_custom(tree: &Value) -> bool { + match tree { + Value::Object(fields) => { + fields + .get("data_type") + .and_then(Value::as_str) + .is_some_and(|tag| tag.eq_ignore_ascii_case(CUSTOM_TYPE_TAG)) + || fields.values().any(has_custom) + } + Value::Array(items) => items.iter().any(has_custom), + _ => false, } } -/// Python's `_normalized_from_parsed_type`. +/// The normalization of a parsed type. pub(crate) fn normalize_parsed( - parsed: DataType, - polyglot: &Dialect, + tree: &Value, + spelling: SpellingDialect, dialect: Option, -) -> Result { - let args: Map = shallow_args(&parsed); - let expression: Expression = Expression::DataType(parsed); - let generated: String = generated_type(&expression, polyglot)?; - let normalized_name: String = upper(&generated).replace(' ', ""); - let dtype_name: String = polyglot_type_name(&args); - let params: Vec = polyglot_type_params(&args); +) -> NormalizedType { + let normalized_name: String = upper(&spell(tree, spelling)).replace(' ', ""); + let dtype_name: String = type_name(tree); + let params: Vec = type_params(tree); let snowflake: bool = dialect == Some(TypeDialect::Snowflake); let bigquery: bool = dialect == Some(TypeDialect::BigQuery); let dtype: &str = dtype_name.as_str(); if bigquery && INTEGER_PARSE_TYPE_NAMES.contains(&dtype) { - return Ok(simple("INT64", TypeFamily::Integer)); + return simple("INT64", TypeFamily::Integer); } if bigquery && dtype == BIGNUMERIC_TYPE_NAME { - return Ok(simple("BIGNUMERIC", TypeFamily::Decimal)); + return simple("BIGNUMERIC", TypeFamily::Decimal); } if bigquery && dtype == FLOAT_WIRE_TYPE_NAME { - return Ok(simple("FLOAT64", TypeFamily::Float)); + return simple("FLOAT64", TypeFamily::Float); } - if dtype == POLYGLOT_CUSTOM_TYPE_NAME { - let raw_name: String = upper(&match args.get("name") { - Some(value) => python_str(value), + if dtype == CUSTOM_TYPE_TAG { + let raw_name: String = upper(&match tree.get("name").and_then(Value::as_str) { + Some(name) => name.to_owned(), None => normalized_name.clone(), }) .replace(' ', ""); if snowflake && raw_name.starts_with("NUMBER") { - return Ok(snowflake_number(&raw_name)); + return snowflake_number(&raw_name); } - return Ok(normalize_with_fallback(&raw_name, dialect)); + return normalize_with_fallback(&raw_name, dialect); } if INTEGER_TYPE_NAMES.contains(&dtype) { if snowflake { - return Ok(snowflake_integer()); + return snowflake_integer(); } - return Ok(simple(&normalized_name, TypeFamily::Integer)); + return simple(&normalized_name, TypeFamily::Integer); } if DECIMAL_TYPE_NAMES.contains(&dtype) { let mut precision: Option = params.first().cloned(); @@ -102,16 +126,16 @@ pub(crate) fn normalize_parsed( scale = Some(INTEGER_SCALE.into()); name = format!("DECIMAL({INTEGER_PRECISION},{INTEGER_SCALE})"); } - return Ok(NormalizedType { + return NormalizedType { normalized_name: name, family: TypeFamily::Decimal, precision, scale, length: None, - }); + }; } if FLOAT_TYPE_NAMES.contains(&dtype) { - return Ok(simple(&normalized_name, TypeFamily::Float)); + return simple(&normalized_name, TypeFamily::Float); } if STRING_TYPE_NAMES.contains(&dtype) { let mut length: Option = params.first().cloned(); @@ -126,30 +150,44 @@ pub(crate) fn normalize_parsed( } else if length.is_some() && SIZED_TEXT_TYPE_NAMES.contains(&base_name) { name = name.replacen(base_name, VARCHAR_TYPE_NAME, 1); } - return Ok(NormalizedType { + return NormalizedType { normalized_name: name, family: TypeFamily::String, precision: None, scale: None, length, - }); + }; } if BOOLEAN_TYPE_NAMES.contains(&dtype) { - return Ok(simple(&normalized_name, TypeFamily::Boolean)); + return simple(&normalized_name, TypeFamily::Boolean); } if TIMESTAMP_TYPE_NAMES.contains(&dtype) { - return Ok(simple( + if bigquery && normalized_name == DATETIME_TYPE_NAME { + return simple(&normalized_name, TypeFamily::Datetime); + } + return simple( ×tamp_normalized_name(&normalized_name, dialect), TypeFamily::Timestamp, - )); + ); } if dtype == DATE_TYPE_NAME { - return Ok(simple(&normalized_name, TypeFamily::Date)); + return simple(&normalized_name, TypeFamily::Date); } if dtype == DATETIME_TYPE_NAME { - return Ok(simple(&normalized_name, TypeFamily::Datetime)); + return simple(&normalized_name, TypeFamily::Datetime); } - Ok(simple(&normalized_name, TypeFamily::Other)) + simple(&normalized_name, TypeFamily::Other) +} + +/// The scalar parameters of a type tree, keyed as the tree names them. +pub(crate) fn type_args(tree: &Value) -> serde_json::Map { + let mut args: serde_json::Map = serde_json::Map::new(); + for (key, value) in tree.as_object().into_iter().flatten() { + if !value.is_array() && !value.is_object() { + args.insert(key.clone(), value.clone()); + } + } + args } /// Snowflake's `NUMBER(p,s)` spelled as a custom type: Python's `DECIMAL` rewrite. @@ -172,57 +210,30 @@ fn snowflake_number(raw_name: &str) -> NormalizedType { } } -/// Python's `_polyglot_type_name`. -fn polyglot_type_name(args: &Map) -> String { - let data_type: String = upper(&match args.get("data_type") { - Some(value) => python_str(value), - None => String::new(), - }); - if let Some((_, alias)) = POLYGLOT_TYPE_NAME_ALIASES - .iter() - .find(|(name, _)| *name == data_type) - { +/// The type's tag, upper-cased with its word separators as the type names spell them. +fn type_name(tree: &Value) -> String { + let tag: String = upper(tree.get("data_type").and_then(Value::as_str).unwrap_or("")); + if let Some((_, alias)) = TYPE_TAG_ALIASES.iter().find(|(name, _)| *name == tag) { return (*alias).to_owned(); } - if data_type == POLYGLOT_CUSTOM_TYPE_NAME { - let name: String = upper(&match args.get("name") { - Some(value) => python_str(value), - None => String::new(), - }) - .replace(' ', ""); + if tag == CUSTOM_TYPE_TAG { + let name: String = + upper(tree.get("name").and_then(Value::as_str).unwrap_or("")).replace(' ', ""); if CUSTOM_NORMALIZATION_TYPE_NAMES.contains(&name.as_str()) { return name; } } - data_type + tag } -/// Python's `_polyglot_type_params`: `int(value)` of each parameter, skipping what it rejects. -fn polyglot_type_params(args: &Map) -> Vec { - let mut params: Vec = Vec::new(); - for key in ["precision", "scale", "length"] { - let Some(value) = args.get(key) else { - continue; - }; - let param: Option = match value { - Value::Null | Value::Array(_) | Value::Object(_) => None, - Value::Bool(flag) => Some(i64::from(*flag).into()), +/// The type's precision, scale and length, in that order, where it has them. +fn type_params(tree: &Value) -> Vec { + ["precision", "scale", "length"] + .iter() + .filter_map(|key| tree.get(*key)) + .filter_map(|value| match value { Value::Number(number) => python_int(&number.to_string()), - Value::String(text) => python_int(text), - }; - params.extend(param); - } - params -} - -/// Python's `str(value)` for the scalar values Polyglot gives a parsed type's tag and name. -fn python_str(value: &Value) -> String { - match value { - Value::String(text) => text.clone(), - Value::Null => "None".to_owned(), - Value::Bool(true) => "True".to_owned(), - Value::Bool(false) => "False".to_owned(), - Value::Number(number) => number.to_string(), - Value::Array(_) | Value::Object(_) => value.to_string(), - } + _ => None, + }) + .collect() } diff --git a/crates/sqlbuild-analysis/src/type_system/_helpers/shallow_args.rs b/crates/sqlbuild-analysis/src/type_system/_helpers/shallow_args.rs deleted file mode 100644 index 411f17c653..0000000000 --- a/crates/sqlbuild-analysis/src/type_system/_helpers/shallow_args.rs +++ /dev/null @@ -1,442 +0,0 @@ -//! The wheel's `DataType.args` scalars, read without walking nested types. - -use std::fmt::Display; - -use serde::ser::{ - Impossible, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, - SerializeTuple, SerializeTupleStruct, SerializeTupleVariant, Serializer, -}; -use serde_json::{Map, Number, Value}; - -/// The top-level scalar fields of one serialized value; nested values are absent. -pub(crate) fn shallow_args(value: &T) -> Map { - value.serialize(Fields::default()).unwrap_or_default() -} - -#[derive(Debug)] -pub(crate) struct Unsupported; - -impl Display for Unsupported { - fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("not a struct") - } -} - -impl std::error::Error for Unsupported {} - -impl serde::ser::Error for Unsupported { - fn custom(_message: T) -> Self { - Self - } -} - -/// Collects one struct's scalar fields. -#[derive(Default)] -struct Fields { - fields: Map, -} - -impl SerializeStruct for Fields { - type Ok = Map; - type Error = Unsupported; - - fn serialize_field( - &mut self, - key: &'static str, - value: &T, - ) -> Result<(), Unsupported> { - if let Some(scalar) = value.serialize(Scalar)? { - let _ = self.fields.insert(key.to_owned(), scalar); - } - Ok(()) - } - - fn end(self) -> Result, Unsupported> { - Ok(self.fields) - } -} - -impl SerializeStructVariant for Fields { - type Ok = Map; - type Error = Unsupported; - - fn serialize_field( - &mut self, - key: &'static str, - value: &T, - ) -> Result<(), Unsupported> { - SerializeStruct::serialize_field(self, key, value) - } - - fn end(self) -> Result, Unsupported> { - Ok(self.fields) - } -} - -impl SerializeMap for Fields { - type Ok = Map; - type Error = Unsupported; - - fn serialize_key(&mut self, _key: &T) -> Result<(), Unsupported> { - Err(Unsupported) - } - - fn serialize_value(&mut self, _value: &T) -> Result<(), Unsupported> { - Err(Unsupported) - } - - fn end(self) -> Result, Unsupported> { - Ok(self.fields) - } -} - -macro_rules! not_a_struct { - ($($method:ident($($argument:ty),*)),* $(,)?) => { - $(fn $method(self, $(_: $argument),*) -> Result { - Err(Unsupported) - })* - }; -} - -impl Serializer for Fields { - type Ok = Map; - type Error = Unsupported; - type SerializeSeq = Impossible; - type SerializeTuple = Impossible; - type SerializeTupleStruct = Impossible; - type SerializeTupleVariant = Impossible; - type SerializeMap = Self; - type SerializeStruct = Self; - type SerializeStructVariant = Self; - - not_a_struct!( - serialize_bool(bool), - serialize_i8(i8), - serialize_i16(i16), - serialize_i32(i32), - serialize_i64(i64), - serialize_u8(u8), - serialize_u16(u16), - serialize_u32(u32), - serialize_u64(u64), - serialize_f32(f32), - serialize_f64(f64), - serialize_char(char), - serialize_str(&str), - serialize_bytes(&[u8]), - serialize_none(), - serialize_unit(), - serialize_unit_struct(&'static str), - serialize_unit_variant(&'static str, u32, &'static str), - ); - - fn serialize_some(self, value: &T) -> Result { - value.serialize(self) - } - - fn serialize_newtype_struct( - self, - _name: &'static str, - value: &T, - ) -> Result { - value.serialize(self) - } - - fn serialize_newtype_variant( - self, - _name: &'static str, - _index: u32, - _variant: &'static str, - _value: &T, - ) -> Result { - Err(Unsupported) - } - - fn serialize_seq(self, _len: Option) -> Result { - Err(Unsupported) - } - - fn serialize_tuple(self, _len: usize) -> Result { - Err(Unsupported) - } - - fn serialize_tuple_struct( - self, - _name: &'static str, - _len: usize, - ) -> Result { - Err(Unsupported) - } - - fn serialize_tuple_variant( - self, - _name: &'static str, - _index: u32, - _variant: &'static str, - _len: usize, - ) -> Result { - Err(Unsupported) - } - - fn serialize_map(self, _len: Option) -> Result { - Ok(self) - } - - fn serialize_struct( - self, - _name: &'static str, - _len: usize, - ) -> Result { - Ok(self) - } - - fn serialize_struct_variant( - self, - _name: &'static str, - _index: u32, - _variant: &'static str, - _len: usize, - ) -> Result { - Ok(self) - } -} - -/// One field's value if it is a scalar; nested values are skipped without visiting them. -struct Scalar; - -/// Swallows the children of a nested value unvisited. -struct Skipped; - -macro_rules! skip_children { - ($($trait:ident :: $method:ident),* $(,)?) => { - $(impl $trait for Skipped { - type Ok = Option; - type Error = Unsupported; - - fn $method(&mut self, _value: &T) -> Result<(), Unsupported> { - Ok(()) - } - - fn end(self) -> Result, Unsupported> { - Ok(None) - } - })* - }; -} - -skip_children!( - SerializeSeq::serialize_element, - SerializeTuple::serialize_element, - SerializeTupleStruct::serialize_field, - SerializeTupleVariant::serialize_field, -); - -impl SerializeMap for Skipped { - type Ok = Option; - type Error = Unsupported; - - fn serialize_key(&mut self, _key: &T) -> Result<(), Unsupported> { - Ok(()) - } - - fn serialize_value(&mut self, _value: &T) -> Result<(), Unsupported> { - Ok(()) - } - - fn end(self) -> Result, Unsupported> { - Ok(None) - } -} - -impl SerializeStruct for Skipped { - type Ok = Option; - type Error = Unsupported; - - fn serialize_field( - &mut self, - _key: &'static str, - _value: &T, - ) -> Result<(), Unsupported> { - Ok(()) - } - - fn end(self) -> Result, Unsupported> { - Ok(None) - } -} - -impl SerializeStructVariant for Skipped { - type Ok = Option; - type Error = Unsupported; - - fn serialize_field( - &mut self, - _key: &'static str, - _value: &T, - ) -> Result<(), Unsupported> { - Ok(()) - } - - fn end(self) -> Result, Unsupported> { - Ok(None) - } -} - -fn number(value: impl Into) -> Result, Unsupported> { - Ok(Some(Value::Number(value.into()))) -} - -impl Serializer for Scalar { - type Ok = Option; - type Error = Unsupported; - type SerializeSeq = Skipped; - type SerializeTuple = Skipped; - type SerializeTupleStruct = Skipped; - type SerializeTupleVariant = Skipped; - type SerializeMap = Skipped; - type SerializeStruct = Skipped; - type SerializeStructVariant = Skipped; - - fn serialize_bool(self, value: bool) -> Result { - Ok(Some(Value::Bool(value))) - } - - fn serialize_i8(self, value: i8) -> Result { - number(value) - } - - fn serialize_i16(self, value: i16) -> Result { - number(value) - } - - fn serialize_i32(self, value: i32) -> Result { - number(value) - } - - fn serialize_i64(self, value: i64) -> Result { - number(value) - } - - fn serialize_u8(self, value: u8) -> Result { - number(value) - } - - fn serialize_u16(self, value: u16) -> Result { - number(value) - } - - fn serialize_u32(self, value: u32) -> Result { - number(value) - } - - fn serialize_u64(self, value: u64) -> Result { - number(value) - } - - fn serialize_f32(self, value: f32) -> Result { - self.serialize_f64(f64::from(value)) - } - - fn serialize_f64(self, value: f64) -> Result { - Ok(Number::from_f64(value).map(Value::Number)) - } - - fn serialize_char(self, value: char) -> Result { - Ok(Some(Value::String(value.to_string()))) - } - - fn serialize_str(self, value: &str) -> Result { - Ok(Some(Value::String(value.to_owned()))) - } - - fn serialize_bytes(self, _value: &[u8]) -> Result { - Ok(None) - } - - fn serialize_none(self) -> Result { - Ok(Some(Value::Null)) - } - - fn serialize_some(self, value: &T) -> Result { - value.serialize(self) - } - - fn serialize_unit(self) -> Result { - Ok(Some(Value::Null)) - } - - fn serialize_unit_struct(self, _name: &'static str) -> Result { - Ok(Some(Value::Null)) - } - - fn serialize_unit_variant( - self, - _name: &'static str, - _index: u32, - variant: &'static str, - ) -> Result { - Ok(Some(Value::String(variant.to_owned()))) - } - - fn serialize_newtype_struct( - self, - _name: &'static str, - value: &T, - ) -> Result { - value.serialize(self) - } - - fn serialize_newtype_variant( - self, - _name: &'static str, - _index: u32, - _variant: &'static str, - _value: &T, - ) -> Result { - Ok(None) - } - - fn serialize_seq(self, _len: Option) -> Result { - Ok(Skipped) - } - - fn serialize_tuple(self, _len: usize) -> Result { - Ok(Skipped) - } - - fn serialize_tuple_struct( - self, - _name: &'static str, - _len: usize, - ) -> Result { - Ok(Skipped) - } - - fn serialize_tuple_variant( - self, - _name: &'static str, - _index: u32, - _variant: &'static str, - _len: usize, - ) -> Result { - Ok(Skipped) - } - - fn serialize_map(self, _len: Option) -> Result { - Ok(Skipped) - } - - fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { - Ok(Skipped) - } - - fn serialize_struct_variant( - self, - _name: &'static str, - _index: u32, - _variant: &'static str, - _len: usize, - ) -> Result { - Ok(Skipped) - } -} diff --git a/crates/sqlbuild-analysis/src/type_system/_helpers/spelling.rs b/crates/sqlbuild-analysis/src/type_system/_helpers/spelling.rs new file mode 100644 index 0000000000..87235d9225 --- /dev/null +++ b/crates/sqlbuild-analysis/src/type_system/_helpers/spelling.rs @@ -0,0 +1,494 @@ +//! Each dialect's spelling of a type tree: the canonical text `same_type` compares. + +use serde_json::Value; + +/// A dialect whose type spellings SQLBuild knows. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum SpellingDialect { + Generic, + Snowflake, + BigQuery, + DuckDb, + Databricks, + Postgres, + Tsql, + Sqlite, + ClickHouse, +} + +impl SpellingDialect { + /// The dialect a name refers to, in any letter case; None for a dialect SQLBuild lacks. + pub(crate) fn named(name: &str) -> Option { + Some(match name.to_ascii_lowercase().as_str() { + "" | "generic" => Self::Generic, + "snowflake" => Self::Snowflake, + "bigquery" => Self::BigQuery, + "duckdb" | "motherduck" => Self::DuckDb, + "databricks" => Self::Databricks, + "postgres" | "postgresql" => Self::Postgres, + "tsql" | "mssql" | "sqlserver" => Self::Tsql, + "sqlite" => Self::Sqlite, + "clickhouse" => Self::ClickHouse, + _ => return None, + }) + } +} + +/// `tree` written as `dialect` spells it. +pub(crate) fn spell(tree: &Value, dialect: SpellingDialect) -> String { + let mut text: String = String::new(); + Speller { + dialect, + text: &mut text, + } + .data_type(tree, false); + text +} + +struct Speller<'a> { + dialect: SpellingDialect, + text: &'a mut String, +} + +impl Speller<'_> { + fn write(&mut self, text: &str) { + self.text.push_str(text); + } + + /// `name`, then `(length)` when there is one. + fn sized(&mut self, name: &str, length: Option) { + self.write(name); + if let Some(length) = length { + self.write(&format!("({length})")); + } + } + + /// `name`, then `(precision)` or `(precision, scale)` when there is a precision. + fn scaled(&mut self, name: &str, precision: Option, scale: Option) { + self.write(name); + if let Some(precision) = precision { + match scale { + Some(scale) => self.write(&format!("({precision}, {scale})")), + None => self.write(&format!("({precision})")), + } + } + } + + /// A ClickHouse scalar, nullable except as a map key. + fn clickhouse(&mut self, name: &str, map_key: bool) { + if map_key { + self.write(name); + } else { + self.write(&format!("Nullable({name})")); + } + } + + fn data_type(&mut self, tree: &Value, map_key: bool) { + let tag: &str = tree.get("data_type").and_then(Value::as_str).unwrap_or(""); + if self.number_type(tree, tag, map_key) + || self.text_type(tree, tag, map_key) + || self.time_type(tree, tag) + { + return; + } + self.other_type(tree, tag); + } + + /// A boolean or numeric type; false for any other tag. + fn number_type(&mut self, tree: &Value, tag: &str, map_key: bool) -> bool { + use SpellingDialect::{ + BigQuery, ClickHouse, Databricks, Postgres, Snowflake, Sqlite, Tsql, + }; + let dialect: SpellingDialect = self.dialect; + let number = |key: &str| tree.get(key).and_then(Value::as_u64); + let flag = |key: &str| tree.get(key).and_then(Value::as_bool).unwrap_or(false); + let length: Option = number("length"); + let precision: Option = number("precision"); + let scale: Option = number("scale"); + match tag { + "boolean" => match dialect { + Tsql => self.write("BIT"), + ClickHouse => self.write("Bool"), + _ => self.write("BOOLEAN"), + }, + "tiny_int" => match dialect { + Postgres => self.sized("SMALLINT", length), + ClickHouse => self.clickhouse("Int8", map_key), + _ => self.sized("TINYINT", length), + }, + "small_int" => match dialect { + Sqlite => self.write("INTEGER"), + BigQuery => self.write("INT64"), + ClickHouse => self.clickhouse("Int16", map_key), + _ => self.sized("SMALLINT", length), + }, + "int" => match dialect { + BigQuery => self.write("INT64"), + ClickHouse => self.clickhouse("Int32", map_key), + Tsql | Sqlite => self.sized("INTEGER", length), + _ => self.sized("INT", length), + }, + "big_int" => match dialect { + BigQuery => self.write("INT64"), + ClickHouse => self.clickhouse("Int64", map_key), + _ => self.sized("BIGINT", length), + }, + "int128" => match dialect { + ClickHouse => self.write("Int128"), + _ => self.write("INT128"), + }, + "uint8" | "uint16" | "uint32" | "uint64" | "uint128" => { + let (canonical, clickhouse) = match tag { + "uint8" => ("UTINYINT", "UInt8"), + "uint16" => ("USMALLINT", "UInt16"), + "uint32" => ("UINTEGER", "UInt32"), + "uint64" => ("UBIGINT", "UInt64"), + _ => ("UINT128", "UInt128"), + }; + self.write(if dialect == ClickHouse { + clickhouse + } else { + canonical + }); + } + "float" if dialect == ClickHouse => { + self.clickhouse("Float32", map_key); + self.scaled("", precision, scale); + } + "double" if dialect == ClickHouse => { + self.clickhouse("Float64", map_key); + self.scaled("", precision, scale); + } + "float" => { + let name: &str = if flag("real_spelling") + && !matches!(dialect, Databricks | Snowflake | BigQuery) + { + "REAL" + } else { + match dialect { + Postgres => "REAL", + BigQuery => "FLOAT64", + _ => "FLOAT", + } + }; + if dialect == Databricks { + self.write(name); + } else { + self.scaled(name, precision, scale); + } + } + "double" => { + let name: &str = match dialect { + Tsql => "FLOAT", + BigQuery => "FLOAT64", + Sqlite => "REAL", + Postgres => "DOUBLE PRECISION", + _ => "DOUBLE", + }; + self.scaled(name, precision, scale); + } + "decimal" => match dialect { + ClickHouse => self.scaled("Decimal", precision, scale), + BigQuery => self.scaled("NUMERIC", precision, scale), + _ => self.scaled("DECIMAL", precision, scale), + }, + _ => return false, + } + true + } + + /// A text, binary, JSON or UUID type; false for any other tag. + fn text_type(&mut self, tree: &Value, tag: &str, map_key: bool) -> bool { + use SpellingDialect::{ + BigQuery, ClickHouse, Databricks, DuckDb, Postgres, Snowflake, Sqlite, Tsql, + }; + let dialect: SpellingDialect = self.dialect; + let number = |key: &str| tree.get(key).and_then(Value::as_u64); + let length: Option = number("length"); + match tag { + "text_with_length" if dialect == ClickHouse => self.write("Nullable(String)"), + "char" | "var_char" | "string" | "text" if dialect == ClickHouse => { + self.write("String"); + } + "char" => match dialect { + DuckDb | Sqlite => self.write("TEXT"), + Databricks if length.is_none() => self.write("STRING"), + _ => self.sized("CHAR", length), + }, + "var_char" => match dialect { + DuckDb | Sqlite => self.sized("TEXT", length), + Databricks if length.is_none() => self.write("STRING"), + _ => self.sized("VARCHAR", length), + }, + "text" => match dialect { + Tsql => self.write("VARCHAR(MAX)"), + BigQuery | Databricks => self.write("STRING"), + Snowflake => self.write("VARCHAR"), + _ => self.write("TEXT"), + }, + "text_with_length" => match dialect { + Databricks | Snowflake | Tsql => self.sized("VARCHAR", length), + BigQuery => self.sized("STRING", length), + _ => self.sized("TEXT", length), + }, + "string" => match dialect { + Postgres if length.is_none() => self.write("TEXT"), + Postgres => self.sized("VARCHAR", length), + Tsql if length.is_none() => self.write("VARCHAR(MAX)"), + Tsql => self.sized("VARCHAR", length), + DuckDb => self.sized("TEXT", length), + _ => self.sized("STRING", length), + }, + "binary" | "var_binary" if dialect == BigQuery => self.sized("BYTES", length), + "binary" => match dialect { + Postgres => self.sized("BYTEA", length), + DuckDb | Sqlite => self.sized("BLOB", length), + _ => self.sized("BINARY", length), + }, + "var_binary" => match dialect { + Postgres => self.sized("BYTEA", length), + DuckDb | Sqlite => self.sized("BLOB", length), + Databricks => self.sized("BINARY", length), + ClickHouse => self.clickhouse("String", map_key), + _ => self.sized("VARBINARY", length), + }, + "blob" => match dialect { + Postgres => self.write("BYTEA"), + Tsql | DuckDb => self.write("VARBINARY"), + BigQuery => self.write("BYTES"), + Databricks => self.write("BINARY"), + ClickHouse => self.write("Nullable(String)"), + _ => self.write("BLOB"), + }, + "bit" => match dialect { + Databricks | Snowflake | BigQuery | ClickHouse => self.write("BOOLEAN"), + _ => self.sized("BIT", length), + }, + "var_bit" => self.sized("VARBIT", length), + "json_b" if dialect == Postgres => self.write("JSONB"), + "json" | "json_b" => match dialect { + Tsql => self.write("NVARCHAR(MAX)"), + Snowflake => self.write("VARIANT"), + _ => self.write("JSON"), + }, + "uuid" => match dialect { + Tsql => self.write("UNIQUEIDENTIFIER"), + BigQuery | Databricks => self.write("STRING"), + _ => self.write("UUID"), + }, + _ => return false, + } + true + } + + /// A date, time, timestamp or interval type; false for any other tag. + fn time_type(&mut self, tree: &Value, tag: &str) -> bool { + use SpellingDialect::{BigQuery, ClickHouse, Databricks, DuckDb, Postgres, Tsql}; + let dialect: SpellingDialect = self.dialect; + let number = |key: &str| tree.get(key).and_then(Value::as_u64); + let flag = |key: &str| tree.get(key).and_then(Value::as_bool).unwrap_or(false); + let precision: Option = number("precision"); + match tag { + "date" => self.write("DATE"), + "time" if flag("timezone") => match dialect { + DuckDb => self.write("TIMETZ"), + Postgres => self.sized("TIMETZ", precision), + _ => { + self.sized("TIME", precision); + self.write(" WITH TIME ZONE"); + } + }, + "time" => match dialect { + Databricks => self.write("TIMESTAMP"), + _ => self.sized("TIME", precision), + }, + "timestamp" => { + let timezone: bool = flag("timezone"); + match dialect { + ClickHouse => self.sized("DateTime", precision), + Tsql if timezone => self.sized("DATETIMEOFFSET", precision), + Tsql => self.sized("DATETIME2", precision), + BigQuery if timezone => self.write("TIMESTAMP"), + BigQuery => self.write("DATETIME"), + DuckDb if timezone => self.write("TIMESTAMPTZ"), + _ if timezone => self.sized("TIMESTAMPTZ", precision), + _ => self.sized("TIMESTAMP", precision), + } + } + "interval" => { + self.write("INTERVAL"); + for (key, prefix) in [("unit", " "), ("to", " TO ")] { + if let Some(unit) = tree.get(key).and_then(Value::as_str) { + self.write(prefix); + self.write(&unit.to_ascii_uppercase()); + } + } + } + _ => return false, + } + true + } + + /// A nested, custom or other type. + fn other_type(&mut self, tree: &Value, tag: &str) { + use SpellingDialect::{ClickHouse, DuckDb, Generic, Postgres, Snowflake, Tsql}; + let dialect: SpellingDialect = self.dialect; + let number = |key: &str| tree.get(key).and_then(Value::as_u64); + match tag { + "array" => { + let element: &Value = tree.get("element_type").unwrap_or(&Value::Null); + match dialect { + Postgres | DuckDb => { + self.data_type(element, false); + match number("dimension") { + Some(dimension) => self.write(&format!("[{dimension}]")), + None => self.write("[]"), + } + } + Snowflake | ClickHouse => { + self.write(if dialect == ClickHouse { + "Array(" + } else { + "ARRAY(" + }); + self.data_type(element, false); + self.write(")"); + } + Tsql => self.write("NVARCHAR(MAX)"), + _ => { + self.write("ARRAY<"); + self.data_type(element, false); + self.write(">"); + } + } + } + "list" => { + self.data_type(tree.get("element_type").unwrap_or(&Value::Null), false); + self.write(" LIST"); + } + "map" => { + let key: &Value = tree.get("key_type").unwrap_or(&Value::Null); + let value: &Value = tree.get("value_type").unwrap_or(&Value::Null); + let (open, close) = match dialect { + Snowflake | DuckDb => ("MAP(", ")"), + ClickHouse => ("Map(", ")"), + _ => ("MAP<", ">"), + }; + self.write(open); + self.data_type(key, dialect == ClickHouse); + self.write(", "); + self.data_type(value, false); + self.write(close); + } + "struct" => self.struct_type(tree), + "object" => self.field_list("OBJECT(", tree), + "union" => self.field_list("UNION(", tree), + "vector" => { + self.write("VECTOR"); + let element: Option<&Value> = tree.get("element_type").filter(|v| !v.is_null()); + let dimension: Option = number("dimension"); + if element.is_some() || dimension.is_some() { + self.write("("); + if let Some(element) = element { + self.data_type(element, false); + if dimension.is_some() { + self.write(", "); + } + } + if let Some(dimension) = dimension { + self.write(&dimension.to_string()); + } + self.write(")"); + } + } + "enum" => { + let values: Vec = tree + .get("values") + .and_then(Value::as_array) + .map_or(&[][..], Vec::as_slice) + .iter() + .map(|value| format!("'{}'", value.as_str().unwrap_or("").replace('\'', "''"))) + .collect(); + self.write(&format!("ENUM({})", values.join(", "))); + } + "custom" => { + let name: &str = tree.get("name").and_then(Value::as_str).unwrap_or(""); + self.write(&custom_name(name, dialect)); + } + _ if dialect == Generic => self.write(&tag.to_ascii_uppercase()), + _ => self.write(&tag.to_ascii_uppercase().replace('_', "")), + } + } + + /// An `OBJECT` or `UNION` of named fields, opened by `open`. + fn field_list(&mut self, open: &str, tree: &Value) { + self.write(open); + let fields: &[Value] = tree + .get("fields") + .and_then(Value::as_array) + .map_or(&[], Vec::as_slice); + for (index, field) in fields.iter().enumerate() { + if index > 0 { + self.write(", "); + } + self.write(field.get(0).and_then(Value::as_str).unwrap_or("")); + self.write(" "); + self.data_type(field.get(1).unwrap_or(&Value::Null), false); + } + self.write(")"); + } + + fn struct_type(&mut self, tree: &Value) { + use SpellingDialect::{BigQuery, ClickHouse, Databricks, DuckDb, Snowflake}; + let dialect: SpellingDialect = self.dialect; + let nested: bool = tree.get("nested").and_then(Value::as_bool).unwrap_or(false); + let (open, close, separator): (&str, &str, &str) = match dialect { + Snowflake => ("OBJECT(", ")", " "), + DuckDb => ("STRUCT(", ")", " "), + ClickHouse => ("Tuple(", ")", " "), + Databricks | BigQuery => ( + "STRUCT<", + ">", + if dialect == Databricks { ": " } else { " " }, + ), + _ if nested => ("STRUCT(", ")", " "), + _ => ("STRUCT<", ">", " "), + }; + self.write(open); + let fields: &[Value] = tree + .get("fields") + .and_then(Value::as_array) + .map_or(&[], Vec::as_slice); + for (index, field) in fields.iter().enumerate() { + if index > 0 { + self.write(", "); + } + let name: &str = field.get("name").and_then(Value::as_str).unwrap_or(""); + if !name.is_empty() { + self.write(name); + self.write(separator); + } + self.data_type(field.get("data_type").unwrap_or(&Value::Null), false); + } + self.write(close); + } +} + +/// A type name no dialect gives its own shape, as `dialect` spells it. +fn custom_name(name: &str, dialect: SpellingDialect) -> String { + let (base, arguments): (&str, &str) = name.find('(').map_or((name, ""), |at| name.split_at(at)); + let base_upper: String = base.trim().to_ascii_uppercase(); + match (dialect, base_upper.as_str()) { + (SpellingDialect::Snowflake, "TIMESTAMP_NTZ" | "TIMESTAMP_LTZ" | "TIMESTAMP_TZ") => { + format!("{}{arguments}", base_upper.replace('_', "")) + } + (SpellingDialect::Tsql, "VARIANT") => "SQL_VARIANT".to_owned(), + ( + SpellingDialect::BigQuery | SpellingDialect::ClickHouse | SpellingDialect::Snowflake, + _, + ) => name.to_owned(), + (_, "INT64") if arguments.is_empty() => "BIGINT".to_owned(), + (_, "FLOAT64") if arguments.is_empty() => "DOUBLE".to_owned(), + _ => name.to_owned(), + } +} diff --git a/crates/sqlbuild-analysis/src/type_system/_helpers/type_reader.rs b/crates/sqlbuild-analysis/src/type_system/_helpers/type_reader.rs new file mode 100644 index 0000000000..d98af083c5 --- /dev/null +++ b/crates/sqlbuild-analysis/src/type_system/_helpers/type_reader.rs @@ -0,0 +1,523 @@ +//! SQLBuild's own type reader, which builds the tree SQLQuack's type parsers build. + +use serde_json::{Map, Value, json}; + +use crate::type_system::_helpers::spelling::SpellingDialect; + +/// The type tree of `type_sql`, or why the reader rejects it. +pub(crate) fn read_type(type_sql: &str, dialect: SpellingDialect) -> Result { + let tokens: Vec = tokens(type_sql, dialect)?; + let mut reader = Reader { + tokens: &tokens, + position: 0, + dialect, + }; + let tree: Value = reader.data_type()?; + if reader.peek() == Some(&Token::Punct(';')) { + reader.position += 1; + } + match reader.peek() { + None => Ok(tree), + Some(token) => Err(format!("unexpected {} after the type", token.text())), + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +enum Token { + Word(String), + Quoted(String), + /// A single-quoted string, such as a ClickHouse enum member or time zone. + Literal(String), + Number(String), + Punct(char), +} + +impl Token { + fn text(&self) -> String { + match self { + Self::Word(text) | Self::Quoted(text) | Self::Literal(text) | Self::Number(text) => { + format!("'{text}'") + } + Self::Punct(character) => format!("'{character}'"), + } + } + + /// The token as a type name writes it. + fn source(&self) -> String { + match self { + Self::Word(text) | Self::Number(text) => text.clone(), + Self::Quoted(text) => format!("\"{text}\""), + Self::Literal(text) => format!("'{}'", text.replace('\'', "''")), + Self::Punct(character) => character.to_string(), + } + } +} + +fn tokens(type_sql: &str, dialect: SpellingDialect) -> Result, String> { + let characters: Vec = type_sql.chars().collect(); + let mut tokens: Vec = Vec::new(); + let mut index: usize = 0; + while let Some(&character) = characters.get(index) { + if character.is_whitespace() { + index += 1; + } else if character.is_alphabetic() || character == '_' { + let start: usize = index; + while characters + .get(index) + .is_some_and(|next| next.is_alphanumeric() || *next == '_' || *next == '$') + { + index += 1; + } + tokens.push(Token::Word(characters[start..index].iter().collect())); + } else if character.is_ascii_digit() { + let start: usize = index; + while characters.get(index).is_some_and(char::is_ascii_digit) { + index += 1; + } + if characters + .get(index) + .is_some_and(|next| next.is_alphabetic() || *next == '_') + { + return Err(format!("invalid identifier at offset {start}")); + } + tokens.push(Token::Number(characters[start..index].iter().collect())); + } else if let Some(close) = quote_close(character, dialect) { + let start: usize = index + 1; + index = start; + while characters.get(index).is_some_and(|next| *next != close) { + index += 1; + } + if index >= characters.len() { + return Err("unterminated quoted name".to_owned()); + } + tokens.push(Token::Quoted(characters[start..index].iter().collect())); + index += 1; + } else if character == '\'' && dialect == SpellingDialect::ClickHouse { + let (literal, end) = literal(&characters, index)?; + tokens.push(Token::Literal(literal)); + index = end; + } else if "()<>,[]:;".contains(character) + || ("=-".contains(character) && dialect == SpellingDialect::ClickHouse) + { + tokens.push(Token::Punct(character)); + index += 1; + } else { + return Err(format!("unexpected character '{character}'")); + } + } + Ok(tokens) +} + +/// The single-quoted string opening at `start`, with `''` and backslash escapes, and the index after it. +fn literal(characters: &[char], start: usize) -> Result<(String, usize), String> { + let mut text: String = String::new(); + let mut index: usize = start + 1; + loop { + match characters.get(index) { + None => return Err("unterminated string".to_owned()), + Some('\\') => { + text.extend(characters.get(index + 1)); + index += 2; + } + Some('\'') if characters.get(index + 1) == Some(&'\'') => { + text.push('\''); + index += 2; + } + Some('\'') => return Ok((text, index + 1)), + Some(&character) => { + text.push(character); + index += 1; + } + } + } +} + +/// The closing quote of a quoted name `open` starts in `dialect`. +fn quote_close(open: char, dialect: SpellingDialect) -> Option { + let backtick: bool = matches!( + dialect, + SpellingDialect::Databricks | SpellingDialect::BigQuery | SpellingDialect::ClickHouse + ); + match open { + '`' if backtick => Some('`'), + '"' if !matches!( + dialect, + SpellingDialect::Databricks | SpellingDialect::BigQuery + ) => + { + Some('"') + } + '[' if dialect == SpellingDialect::Tsql => Some(']'), + _ => None, + } +} + +struct Reader<'a> { + tokens: &'a [Token], + position: usize, + dialect: SpellingDialect, +} + +impl Reader<'_> { + fn peek(&self) -> Option<&Token> { + self.tokens.get(self.position) + } + + fn next(&mut self) -> Option { + let token: Option = self.peek().cloned(); + self.position += usize::from(token.is_some()); + token + } + + fn eat_punct(&mut self, character: char) -> bool { + let found: bool = self.peek() == Some(&Token::Punct(character)); + self.position += usize::from(found); + found + } + + fn expect_punct(&mut self, character: char) -> Result<(), String> { + if self.eat_punct(character) { + return Ok(()); + } + Err(match self.peek() { + Some(token) => format!("expected '{character}', found {}", token.text()), + None => format!("expected '{character}' at the end of the type"), + }) + } + + fn eat_word(&mut self, word: &str) -> bool { + let found: bool = + matches!(self.peek(), Some(Token::Word(text)) if text.eq_ignore_ascii_case(word)); + self.position += usize::from(found); + found + } + + fn data_type(&mut self) -> Result { + let mut tree: Value = self.base_type()?; + while self.eat_punct('[') { + let dimension: Option = match self.peek() { + Some(Token::Number(_)) => Some(self.number()?), + _ => None, + }; + self.expect_punct(']')?; + let mut array: Map = Map::new(); + array.insert("data_type".to_owned(), json!("array")); + array.insert("element_type".to_owned(), tree); + if let Some(dimension) = dimension { + array.insert("dimension".to_owned(), json!(dimension)); + } + tree = Value::Object(array); + } + Ok(tree) + } + + fn base_type(&mut self) -> Result { + match self.next() { + Some(Token::Quoted(name)) => self.custom(name), + Some(Token::Word(word)) => self.named_type(&word), + other => Err(unexpected("a type name", other.as_ref())), + } + } + + fn named_type(&mut self, word: &str) -> Result { + let upper: String = word.to_ascii_uppercase(); + match upper.as_str() { + "ARRAY" => { + let close: char = self.open_nested()?; + let element: Value = self.data_type()?; + self.expect_punct(close)?; + Ok(json!({"data_type": "array", "element_type": element})) + } + "MAP" => { + let close: char = self.open_nested()?; + let key: Value = self.data_type()?; + self.expect_punct(',')?; + let value: Value = self.data_type()?; + self.expect_punct(close)?; + Ok(json!({"data_type": "map", "key_type": key, "value_type": value})) + } + "STRUCT" => { + let close: char = self.open_nested()?; + let mut fields: Vec = Vec::new(); + loop { + let name: String = match self.next() { + Some(Token::Word(name) | Token::Quoted(name)) => name, + _ => return Err("expected a struct field name".to_owned()), + }; + self.eat_punct(':'); + let data_type: Value = self.data_type()?; + fields.push(json!({"name": name, "data_type": data_type})); + if !self.eat_punct(',') { + break; + } + } + self.expect_punct(close)?; + Ok(json!({"data_type": "struct", "fields": fields, "nested": close == ')'})) + } + "DOUBLE" => { + self.eat_word("PRECISION"); + let (precision, scale) = self.precision_scale()?; + Ok(json!({"data_type": "double", "precision": precision, "scale": scale})) + } + "CHARACTER" | "CHAR" if self.eat_word("VARYING") => { + let length: Option = self.text_length(Self::length)?; + Ok(json!({"data_type": "var_char", "length": length})) + } + "TIMESTAMP" => self.time_type("timestamp", self.dialect == SpellingDialect::BigQuery), + "TIME" => self.time_type("time", false), + _ => self.scalar_type(word, &upper), + } + } + + /// A time or timestamp; `zoned` when the bare type has a time zone, as in BigQuery. + fn time_type(&mut self, tag: &str, zoned: bool) -> Result { + let precision: Option = self.length()?; + let timezone: bool = self.time_zone()?.unwrap_or(zoned); + Ok(json!({"data_type": tag, "precision": precision, "timezone": timezone})) + } + + /// The opening bracket of a nested type's parameters, returning its closing bracket. + fn open_nested(&mut self) -> Result { + if self.eat_punct('<') { + return Ok('>'); + } + self.expect_punct('(')?; + Ok(')') + } + + /// `WITH TIME ZONE` or `WITHOUT TIME ZONE` after a time type, None when neither follows. + fn time_zone(&mut self) -> Result, String> { + let timezone: bool = if self.eat_word("WITH") { + true + } else if self.eat_word("WITHOUT") { + false + } else { + return Ok(None); + }; + if self.eat_word("TIME") && self.eat_word("ZONE") { + return Ok(Some(timezone)); + } + Err("expected TIME ZONE".to_owned()) + } + + fn scalar_type(&mut self, word: &str, upper: &str) -> Result { + let tagged = |tag: &str, length: Option| json!({"data_type": tag, "length": length}); + Ok(match upper { + "INT" | "INTEGER" => tagged("int", self.sized_length()?), + "BIGINT" => tagged("big_int", self.sized_length()?), + "SMALLINT" => tagged("small_int", self.sized_length()?), + "TINYINT" => tagged("tiny_int", self.sized_length()?), + "VARCHAR" => { + if self.max_length() { + return Ok(json!({"data_type": "custom", "name": upper})); + } + tagged("var_char", self.text_length(Self::sized_length)?) + } + "CHAR" | "CHARACTER" => tagged("char", self.text_length(Self::sized_length)?), + "STRING" => tagged("string", self.text_length(Self::length)?), + "BINARY" => tagged("binary", self.length()?), + "GEOGRAPHY" if self.single_geography() => { + if !self.max_length() { + self.length()?; + } + json!({"data_type": "custom", "name": upper}) + } + "VARBINARY" | "NVARCHAR" | "GEOGRAPHY" if self.max_length() => { + json!({"data_type": "custom", "name": format!("{upper}(MAX)")}) + } + "VARBINARY" => tagged("var_binary", self.length()?), + "TEXT" | "NTEXT" => match self.length()? { + Some(length) => json!({"data_type": "text_with_length", "length": length}), + None => json!({"data_type": "text"}), + }, + "DECIMAL" | "NUMERIC" => { + let (precision, scale) = self.precision_scale()?; + json!({"data_type": "decimal", "precision": precision, "scale": scale}) + } + "FLOAT" => self.float_type(false)?, + "REAL" => self.float_type(true)?, + "TIMESTAMPTZ" | "TIMESTAMP_TZ" => { + let precision: Option = self.length()?; + json!({"data_type": "timestamp", "precision": precision, "timezone": true}) + } + "DATETIME" if self.max_length() => json!({"data_type": "custom", "name": upper}), + "TIMESTAMPNTZ" | "TIMESTAMP_NTZ" | "TIMESTAMPLTZ" | "TIMESTAMP_LTZ" | "DATETIME" => { + let _precision: Option = self.length()?; + json!({"data_type": "custom", "name": upper.replace('_', "")}) + } + "BOOL" | "BOOLEAN" => json!({"data_type": "boolean"}), + "DATE" => json!({"data_type": "date"}), + "INTERVAL" => json!({"data_type": "interval"}), + "JSON" => json!({"data_type": "json"}), + "JSONB" => json!({"data_type": "json_b"}), + "UUID" => json!({"data_type": "uuid"}), + "BLOB" => json!({"data_type": "blob"}), + "HUGEINT" => json!({"data_type": "int128"}), + "LONG" => json!({"data_type": "custom", "name": upper}), + "NVARCHAR" | "GEOGRAPHY" => { + let length: Option = self.length()?; + let name: String = match length { + Some(length) => format!("{upper}({length})"), + None => upper.to_owned(), + }; + json!({"data_type": "custom", "name": name}) + } + _ => return self.custom(word.to_owned()), + }) + } + + /// Whether the dialect has one GEOGRAPHY, which takes no parameters: BigQuery and Snowflake. + fn single_geography(&self) -> bool { + matches!( + self.dialect, + SpellingDialect::BigQuery | SpellingDialect::Snowflake + ) + } + + /// A FLOAT or REAL; Postgres's REAL is a 4-byte float, whatever precision follows it. + fn float_type(&mut self, real: bool) -> Result { + let (mut precision, mut scale) = self.precision_scale()?; + if real && self.dialect == SpellingDialect::Postgres { + (precision, scale) = (None, None); + } + Ok(json!({ + "data_type": "float", + "precision": precision, + "scale": scale, + "real_spelling": real, + })) + } + + /// Any other type name with any number of integer parameters, kept as written. + fn custom(&mut self, name: String) -> Result { + if !self.eat_punct('(') { + return Ok(json!({"data_type": "custom", "name": name})); + } + if self.eat_punct(')') { + return Ok(json!({"data_type": "custom", "name": format!("{name}()")})); + } + let mut parameters: Vec = Vec::new(); + loop { + match self.dialect { + SpellingDialect::ClickHouse => parameters.push(self.clickhouse_parameter(&name)?), + _ => match self.next() { + Some(Token::Number(number)) => parameters.push(number), + Some(Token::Word(word)) => parameters.push(word), + _ => return Err(format!("expected a parameter of {name}")), + }, + } + if !self.eat_punct(',') { + break; + } + } + self.expect_punct(')')?; + Ok(json!({"data_type": "custom", "name": format!("{name}({})", parameters.join(", "))})) + } + + /// One ClickHouse type parameter as written: a nested type, as in `Nullable(DateTime64(3))`, + /// a named tuple field, or an enum member and its value. + fn clickhouse_parameter(&mut self, name: &str) -> Result { + let mut text: String = String::new(); + let mut depth: usize = 0; + let mut spaced: bool = false; + loop { + let token: Token = match self.peek() { + None => return Err(format!("expected ')' after the parameters of {name}")), + Some(Token::Punct(',' | ')')) if depth == 0 => break, + Some(token) => token.clone(), + }; + self.position += 1; + let word: bool = !matches!(token, Token::Punct(_)); + match token { + Token::Punct('(') => depth += 1, + Token::Punct(')') => depth -= 1, + _ => {} + } + if token == Token::Punct('=') { + text.push_str(" = "); + spaced = false; + continue; + } + if word && spaced { + text.push(' '); + } + text.push_str(&token.source()); + spaced = word; + } + if text.is_empty() { + return Err(format!("expected a parameter of {name}")); + } + Ok(text) + } + + /// The optional length of an integer or character type; empty parentheses state none. + fn sized_length(&mut self) -> Result, String> { + if self.peek() == Some(&Token::Punct('(')) + && self.tokens.get(self.position + 1) == Some(&Token::Punct(')')) + { + self.position += 2; + return Ok(None); + } + self.length() + } + + /// A character type's length, which ClickHouse reads and drops: its `String` has none. + fn text_length( + &mut self, + read: fn(&mut Self) -> Result, String>, + ) -> Result, String> { + let length: Option = read(self)?; + Ok(length.filter(|_| self.dialect != SpellingDialect::ClickHouse)) + } + + /// A parenthesized `MAX`, which only the variable-length types take. + fn max_length(&mut self) -> bool { + let found: bool = self.peek() == Some(&Token::Punct('(')) + && matches!(self.tokens.get(self.position + 1), Some(Token::Word(word)) if word.eq_ignore_ascii_case("MAX")) + && self.tokens.get(self.position + 2) == Some(&Token::Punct(')')); + self.position += if found { 3 } else { 0 }; + found + } + + /// One optional parenthesized integer. + fn length(&mut self) -> Result, String> { + if !self.eat_punct('(') { + return Ok(None); + } + let length: u32 = self.number()?; + self.expect_punct(')')?; + Ok(Some(length)) + } + + /// An optional parenthesized precision and scale. + fn precision_scale(&mut self) -> Result<(Option, Option), String> { + if !self.eat_punct('(') { + return Ok((None, None)); + } + let precision: u32 = self.number()?; + let scale: Option = if self.eat_punct(',') { + Some(self.number()?) + } else { + None + }; + self.expect_punct(')')?; + Ok((Some(precision), scale)) + } + + fn number(&mut self) -> Result { + match self.next() { + Some(Token::Number(number)) => number + .parse::() + .map_err(|_| format!("invalid number: {number}")), + other => Err(unexpected("a number", other.as_ref())), + } + } +} + +/// Why `found`, or the end of the type, is not the `expected` token. +fn unexpected(expected: &str, found: Option<&Token>) -> String { + match found { + Some(token) => format!("expected {expected}, found {}", token.text()), + None => format!("expected {expected}"), + } +} diff --git a/crates/sqlbuild-analysis/src/type_system/constants.rs b/crates/sqlbuild-analysis/src/type_system/constants.rs index e5d79cc893..8fd1b089fb 100644 --- a/crates/sqlbuild-analysis/src/type_system/constants.rs +++ b/crates/sqlbuild-analysis/src/type_system/constants.rs @@ -9,7 +9,14 @@ pub(crate) const FLOAT_TYPE_NAMES: &[&str] = &["DOUBLE", "FLOAT", "FLOAT64", "RE pub(crate) const INTEGER_TYPE_NAMES: &[&str] = &[ "BIGINT", "INT", "INT64", "INTEGER", "LONG", "SMALLINT", "TINYINT", ]; -pub(crate) const POLYGLOT_CUSTOM_TYPE_NAME: &str = "CUSTOM"; +/// The deepest type nesting SQLBuild reads: SQLQuack's syntax tree depth. +pub(crate) const MAX_TYPE_NESTING: usize = 512; +/// The type nesting read on the caller's stack; deeper types get their own. +pub(crate) const SHALLOW_TYPE_NESTING: usize = 32; +/// The stack a more deeply nested type is read and normalized on. +pub(crate) const DEEP_TYPE_STACK_BYTES: usize = 32 * 1024 * 1024; +/// The tag of a type name no dialect gives its own shape. +pub(crate) const CUSTOM_TYPE_TAG: &str = "CUSTOM"; pub(crate) const STRING_TYPE_NAMES: &[&str] = &["CHAR", "CHARACTER", "STRING", "TEXT", "VARCHAR"]; pub(crate) const TIMESTAMP_TYPE_NAMES: &[&str] = &["TIMESTAMP", "TIMESTAMPLTZ", "TIMESTAMPNTZ", "TIMESTAMPTZ"]; @@ -31,16 +38,14 @@ pub(crate) const SIZED_TEXT_TYPE_NAMES: &[&str] = &["STRING", "TEXT"]; pub(crate) const VARCHAR_TYPE_NAME: &str = "VARCHAR"; /// BigQuery's one spelling of every variable-length text type. pub(crate) const BIGQUERY_STRING_TYPE_NAME: &str = "STRING"; -/// Polyglot `data_type` tags whose Python spelling drops the word separator. -pub(crate) const POLYGLOT_TYPE_NAME_ALIASES: &[(&str, &str)] = &[ +/// Type tags whose type name drops the word separator. +pub(crate) const TYPE_TAG_ALIASES: &[(&str, &str)] = &[ ("BIG_INT", "BIGINT"), ("SMALL_INT", "SMALLINT"), ("TEXT_WITH_LENGTH", "TEXT"), ("TINY_INT", "TINYINT"), ("VAR_CHAR", "VARCHAR"), ]; -/// The function call depth limit SQLBuild passes to every Polyglot parse. -pub(crate) const MAX_FUNCTION_CALL_DEPTH: usize = 512; /// Python's `str(0)`, the only integer text Python treats as false. pub(crate) const ZERO_TEXT: &str = "0"; /// Snowflake time and timestamp types, word separators removed, whose precision metadata omits. diff --git a/crates/sqlbuild-analysis/src/type_system/errors.rs b/crates/sqlbuild-analysis/src/type_system/errors.rs index 05145a1c60..d8aae3d875 100644 --- a/crates/sqlbuild-analysis/src/type_system/errors.rs +++ b/crates/sqlbuild-analysis/src/type_system/errors.rs @@ -1,12 +1,10 @@ //! Why type normalization fails. -/// Why Python's `normalize_type` raises instead of returning a type. +/// Why `normalize_type` raises instead of returning a type. #[derive(Debug, Clone, PartialEq, Eq)] pub enum TypeNormalizationError { - /// Polyglot does not know the dialect name: the wheel's `ValueError`. + /// SQLBuild has no type rules for the dialect name: Python's `ValueError`. UnknownDialect(String), - /// Polyglot cannot write the parsed type back as SQL: the wheel's `PolyglotError`. - Generation(String), } impl TypeNormalizationError { @@ -15,7 +13,6 @@ impl TypeNormalizationError { pub fn message(&self) -> String { match self { Self::UnknownDialect(name) => format!("Unknown dialect: {name}"), - Self::Generation(message) => message.clone(), } } } diff --git a/crates/sqlbuild-analysis/src/type_system/main/mod.rs b/crates/sqlbuild-analysis/src/type_system/main/mod.rs index 7434eded53..23df8a93ee 100644 --- a/crates/sqlbuild-analysis/src/type_system/main/mod.rs +++ b/crates/sqlbuild-analysis/src/type_system/main/mod.rs @@ -1,3 +1,3 @@ pub mod normalize_type; -pub mod polyglot_type_args; pub mod same_type; +pub mod type_args; diff --git a/crates/sqlbuild-analysis/src/type_system/main/normalize_type.rs b/crates/sqlbuild-analysis/src/type_system/main/normalize_type.rs index ef9005288c..cf32a9cd8f 100644 --- a/crates/sqlbuild-analysis/src/type_system/main/normalize_type.rs +++ b/crates/sqlbuild-analysis/src/type_system/main/normalize_type.rs @@ -1,36 +1,34 @@ -//! Python's `normalize_type`: Polyglot's parsed type first, then the text fallback. - -use polyglot_sql::{Dialect, DialectType}; +//! Python's `normalize_type`: the parsed type first, then the text fallback. use crate::type_system::_helpers::dialects::coerce_type_dialect; use crate::type_system::_helpers::fallback::normalize_with_fallback; -use crate::type_system::_helpers::parsed::{normalize_parsed, parse_type}; +use crate::type_system::_helpers::parsed::{nesting_bound, normalize_parsed, parse_type}; +use crate::type_system::_helpers::spelling::SpellingDialect; +use crate::type_system::constants::{DEEP_TYPE_STACK_BYTES, SHALLOW_TYPE_NESTING}; use crate::type_system::errors::TypeNormalizationError; use crate::type_system::models::{TypeDialect, TypeNormalization}; -/// Normalize one type as Python does for the dialect name it hands Polyglot. +/// Normalize one type in the named dialect. pub fn normalize_type( type_sql: &str, dialect: &str, ) -> Result { - let name: &str = if dialect.is_empty() { - "generic" - } else { - dialect - }; - let polyglot: Dialect = name - .parse::() - .map(Dialect::get) - .map_err(|_| TypeNormalizationError::UnknownDialect(name.to_owned()))?; + let spelling: SpellingDialect = SpellingDialect::named(dialect) + .ok_or_else(|| TypeNormalizationError::UnknownDialect(dialect.to_owned()))?; let type_dialect: Option = coerce_type_dialect(dialect); - match parse_type(type_sql, &polyglot) { - Ok(parsed) => Ok(TypeNormalization { - normalized: normalize_parsed(parsed, &polyglot, type_dialect)?, + let normalize = || match parse_type(type_sql, spelling) { + Ok(tree) => TypeNormalization { + normalized: normalize_parsed(&tree, spelling, type_dialect), parse_error: None, - }), - Err(error) => Ok(TypeNormalization { + }, + Err(error) => TypeNormalization { normalized: normalize_with_fallback(type_sql, type_dialect), parse_error: Some(error), - }), - } + }, + }; + Ok(if nesting_bound(type_sql) > SHALLOW_TYPE_NESTING { + stacker::grow(DEEP_TYPE_STACK_BYTES, normalize) + } else { + normalize() + }) } diff --git a/crates/sqlbuild-analysis/src/type_system/main/polyglot_type_args.rs b/crates/sqlbuild-analysis/src/type_system/main/polyglot_type_args.rs deleted file mode 100644 index 972ac1f6c0..0000000000 --- a/crates/sqlbuild-analysis/src/type_system/main/polyglot_type_args.rs +++ /dev/null @@ -1,17 +0,0 @@ -//! The scalar arguments of a type as Polyglot parses it. - -use polyglot_sql::{DataType, Dialect, DialectType}; -use serde_json::{Map, Value}; - -use crate::type_system::_helpers::parsed::parse_type; -use crate::type_system::_helpers::shallow_args::shallow_args; - -/// `parse_data_type(type_sql, dialect=...).args` scalars, or the parse error text. -pub fn polyglot_type_args(type_sql: &str, dialect: &str) -> Result, String> { - let polyglot: Dialect = dialect - .parse::() - .map(Dialect::get) - .map_err(|_| format!("unknown dialect '{dialect}'"))?; - let parsed: DataType = parse_type(type_sql, &polyglot)?; - Ok(shallow_args(&parsed)) -} diff --git a/crates/sqlbuild-analysis/src/type_system/main/type_args.rs b/crates/sqlbuild-analysis/src/type_system/main/type_args.rs new file mode 100644 index 0000000000..6d92cf07cc --- /dev/null +++ b/crates/sqlbuild-analysis/src/type_system/main/type_args.rs @@ -0,0 +1,13 @@ +//! The scalar arguments of a parsed type. + +use serde_json::{Map, Value}; + +use crate::type_system::_helpers::parsed::{parse_type, type_args as tree_args}; +use crate::type_system::_helpers::spelling::SpellingDialect; + +/// The tag, name, length, precision and scale of `type_sql` in `dialect`, or the parse error. +pub fn type_args(type_sql: &str, dialect: &str) -> Result, String> { + let spelling: SpellingDialect = + SpellingDialect::named(dialect).ok_or_else(|| format!("unknown dialect '{dialect}'"))?; + parse_type(type_sql, spelling).map(|tree| tree_args(&tree)) +} diff --git a/crates/sqlbuild-analysis/src/type_system/models.rs b/crates/sqlbuild-analysis/src/type_system/models.rs index 9497d5bf9f..28323983d0 100644 --- a/crates/sqlbuild-analysis/src/type_system/models.rs +++ b/crates/sqlbuild-analysis/src/type_system/models.rs @@ -101,7 +101,7 @@ pub struct NormalizedType { pub length: Option, } -/// A normalized type and the Polyglot parse error Python logs before its text fallback. +/// A normalized type and the parse error logged before its text fallback. #[derive(Debug, Clone, PartialEq, Eq)] pub struct TypeNormalization { pub normalized: NormalizedType, diff --git a/crates/sqlbuild-analysis/src/type_system/tests/alias_groups.json b/crates/sqlbuild-analysis/src/type_system/tests/alias_groups.json new file mode 100644 index 0000000000..ba75108724 --- /dev/null +++ b/crates/sqlbuild-analysis/src/type_system/tests/alias_groups.json @@ -0,0 +1,298 @@ +{ + "bigquery": [ + ["ARRAY< FLOAT64(10,2) >", "FLOAT64(10,2) []"], + ["ARRAY< TIMESTAMP_NTZ(0)>", "TIMESTAMPNTZ(0) []"], + ["ARRAY", "DECIMAL(10,2)[]"], + ["ARRAY", "ARRAY", "INT[]", "SMALLINT(10) []"], + ["ARRAY", "ARRAY"], + ["BIGDECIMAL( 38 , 0 )", "DECIMAL( 38 , 0 )", "number( 38 , 0 )", "NUMERIC( 38 , 0 )"], + ["BIGDECIMAL(10,2)", "DECIMAL(10, 2)", "NUMBER(10,2)", "NUMERIC(10,2)"], + ["BIGINT", "BIGINT(10)", "INT", "INT(10)", "INT64", "INT64( 38 , 0 )", "INT64(10)", "INT64(10,2)", "INT64(MAX)", "integer", "integer(10)", "LONG", "LONG(10)", "SMALLINT", "SMALLINT(10)"], + ["BLOB", "bytes"], + ["BOOL", "BOOLEAN"], + ["CHAR", "CHARACTER"], + ["CHAR(10)", "CHARACTER(10)"], + ["CHARACTER VARYING(10)", "string(10)", "TEXT(10)", "VARCHAR(10)"], + ["DATETIME", "DATETIME(0)", "DATETIME(10)"], + ["DOUBLE", "DOUBLE PRECISION", "FLOAT", "FLOAT64", "FLOAT64( 38 , 0 )", "FLOAT64(10)", "FLOAT64(10, 2)", "FLOAT64(MAX)", "REAL"], + ["DOUBLE PRECISION(10)", "DOUBLE(10)", "FLOAT(10)", "REAL(10)"], + ["GEOGRAPHY", "GEOGRAPHY(10)"], + ["STRUCT(a INT)", "STRUCT(a INTEGER(10) )"], + ["TIMESTAMP", "TIMESTAMP(0)", "timestamp(10)"], + ["TIMESTAMP WITH TIME ZONE", "TIMESTAMPTZ", "timestamptz(0)", "TIMESTAMPTZ(10)", "TIMESTAMP_TZ", "TIMESTAMP_TZ(0)", "TIMESTAMP_TZ(10)"], + ["TIMESTAMPNTZ", "TIMESTAMPNTZ(0)", "TIMESTAMPNTZ(10)", "TIMESTAMP_NTZ", "TIMESTAMP_NTZ(0)", "TIMESTAMP_NTZ(10)"], + ["TIMESTAMP_LTZ", "TIMESTAMP_LTZ(0)", "TIMESTAMP_LTZ(10)"], + ["bigdecimal", "decimal", "NUMBER", "NUMERIC"], + ["bigdecimal(10)", "decimal(10)", "NUMBER(10)", "NUMERIC(10)"], + ["bool(10)", "BOOLEAN(10)"], + ["character varying", "STRING", "TEXT", "VARCHAR", "VARCHAR(MAX)"], + ["date", "DATE(10)"] + ], + "clickhouse": [ + ["BIGINT", "BIGINT(10)"], + ["BLOB", "Nullable(String)"], + ["Bool", "BOOL(10)", "BOOLEAN"], + ["CHAR", "CHAR(10)", "CHARACTER", "CHARACTER VARYING", "CHARACTER VARYING(10)", "CHARACTER(10)", "String", "STRING(10)", "TEXT", "VARCHAR", "VARCHAR(10)"], + ["DECIMAL", "NUMERIC"], + ["DECIMAL(10)", "NUMERIC(10)"], + ["DECIMAL(10,2)", "NUMERIC(10,2)"], + ["DOUBLE", "DOUBLE PRECISION"], + ["DOUBLE PRECISION(10)", "DOUBLE(10)"], + ["Date", "DATE(10)"], + ["DateTime", "DateTime('UTC')", "DATETIME(10)"], + ["FLOAT", "REAL"], + ["FLOAT(10)", "REAL(10)"], + ["Float64", "FLOAT64(10)", "FLOAT64(10,2)"], + ["INT", "INT(10)", "INTEGER", "INTEGER(10)"], + ["Int64", "INT64(10)", "INT64(10,2)"], + ["LONG", "LONG(10)"], + ["SMALLINT", "SMALLINT(10)"], + ["TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITHOUT TIME ZONE", "TIMESTAMPTZ", "TIMESTAMP_TZ"], + ["TIMESTAMP(10)", "TIMESTAMPTZ(10)", "TIMESTAMP_TZ(10)"], + ["TIMESTAMPNTZ", "TIMESTAMPNTZ(10)", "TIMESTAMP_NTZ", "TIMESTAMP_NTZ(10)"], + ["TIMESTAMP_LTZ", "TIMESTAMP_LTZ(10)"], + ["TINYINT", "TINYINT(10)"] + ], + "databricks": [ + ["ARRAY< FLOAT64(10,2) >", "FLOAT64(10,2) []"], + ["ARRAY< TIMESTAMP_NTZ(0)>", "TIMESTAMPNTZ(0) []"], + ["ARRAY", "DECIMAL(10,2)[]"], + ["ARRAY", "INT[]"], + ["ARRAY", "ARRAY"], + ["BIGINT", "INT64"], + ["BOOL", "BOOLEAN", "BOOLEAN(10)"], + ["CHAR", "CHARACTER", "character varying", "STRING", "TEXT", "VARCHAR"], + ["CHAR(10)", "CHARACTER(10)"], + ["CHARACTER VARYING(10)", "string(10)", "TEXT(10)", "VARCHAR(10)"], + ["DATETIME", "DATETIME(0)", "DATETIME(10)"], + ["DECIMAL( 38 , 0 )", "NUMERIC( 38 , 0 )"], + ["DECIMAL(10, 2)", "NUMERIC(10,2)"], + ["DOUBLE", "DOUBLE PRECISION", "FLOAT64"], + ["DOUBLE PRECISION(10)", "DOUBLE(10)"], + ["FLOAT", "FLOAT(10)", "REAL", "REAL(10)"], + ["FLOAT64( 38 , 0 )", "FLOAT64(10)", "FLOAT64(10, 2)", "FLOAT64(MAX)"], + ["INT", "integer"], + ["INT(10)", "integer(10)"], + ["INT64( 38 , 0 )", "INT64(10)", "INT64(10,2)", "INT64(MAX)"], + ["LONG", "LONG(10)"], + ["TIMESTAMP", "TIMESTAMP WITHOUT TIME ZONE"], + ["TIMESTAMP WITH TIME ZONE", "TIMESTAMPTZ", "TIMESTAMP_TZ"], + ["TIMESTAMPNTZ", "TIMESTAMPNTZ(0)", "TIMESTAMPNTZ(10)", "TIMESTAMP_NTZ", "TIMESTAMP_NTZ(0)", "TIMESTAMP_NTZ(10)"], + ["TIMESTAMPTZ(10)", "TIMESTAMP_TZ(10)"], + ["TIMESTAMP_LTZ", "TIMESTAMP_LTZ(0)", "TIMESTAMP_LTZ(10)"], + ["binary", "BLOB"], + ["date", "DATE(10)"], + ["decimal", "NUMERIC"], + ["decimal(10)", "NUMERIC(10)"], + ["time", "TIME(0)", "TIME(10)"], + ["timestamptz(0)", "TIMESTAMP_TZ(0)"] + ], + "duckdb": [ + ["ARRAY< FLOAT64(10,2) >", "FLOAT64(10,2) []"], + ["ARRAY< TIMESTAMP_NTZ(0)>", "TIMESTAMPNTZ(0) []"], + ["ARRAY", "DECIMAL(10,2)[]"], + ["ARRAY", "INTEGER[]", "INT[]"], + ["ARRAY", "ARRAY"], + ["BIGINT", "INT64"], + ["BOOL", "BOOLEAN", "BOOLEAN(10)"], + ["CHAR", "CHARACTER", "character varying", "STRING", "TEXT", "VARCHAR"], + ["CHAR(10)", "CHARACTER(10)"], + ["CHARACTER VARYING(10)", "string(10)", "TEXT(10)", "VARCHAR(10)"], + ["DATETIME", "DATETIME(0)", "DATETIME(10)"], + ["DECIMAL( 38 , 0 )", "NUMERIC( 38 , 0 )"], + ["DECIMAL(10, 2)", "NUMERIC(10,2)"], + ["DOUBLE", "DOUBLE PRECISION", "FLOAT64"], + ["DOUBLE PRECISION(10)", "DOUBLE(10)"], + ["FLOAT64( 38 , 0 )", "FLOAT64(10)", "FLOAT64(10, 2)", "FLOAT64(MAX)"], + ["INT", "integer"], + ["INT(10)", "integer(10)"], + ["INT64( 38 , 0 )", "INT64(10)", "INT64(10,2)", "INT64(MAX)"], + ["LONG", "LONG(10)"], + ["TIMESTAMP", "TIMESTAMP WITHOUT TIME ZONE"], + ["TIMESTAMP WITH TIME ZONE", "TIMESTAMPTZ", "timestamptz(0)", "TIMESTAMPTZ(10)", "TIMESTAMP_TZ", "TIMESTAMP_TZ(0)", "TIMESTAMP_TZ(10)"], + ["TIMESTAMPNTZ", "TIMESTAMPNTZ(0)", "TIMESTAMPNTZ(10)", "TIMESTAMP_NTZ", "TIMESTAMP_NTZ(0)", "TIMESTAMP_NTZ(10)"], + ["TIMESTAMP_LTZ", "TIMESTAMP_LTZ(0)", "TIMESTAMP_LTZ(10)"], + ["date", "DATE(10)"], + ["decimal", "NUMERIC"], + ["decimal(10)", "NUMERIC(10)"] + ], + "generic": [ + ["ARRAY< FLOAT64(10,2) >", "FLOAT64(10,2) []"], + ["ARRAY< TIMESTAMP_NTZ(0)>", "TIMESTAMPNTZ(0) []"], + ["ARRAY", "DECIMAL(10,2)[]"], + ["ARRAY", "INT[]"], + ["ARRAY", "ARRAY"], + ["BIGINT", "INT64"], + ["BOOL", "BOOLEAN", "BOOLEAN(10)"], + ["CHAR", "CHARACTER"], + ["CHAR(10)", "CHARACTER(10)"], + ["CHARACTER VARYING(10)", "string(10)", "TEXT(10)", "VARCHAR(10)"], + ["DATETIME", "DATETIME(0)", "DATETIME(10)"], + ["DECIMAL( 38 , 0 )", "NUMERIC( 38 , 0 )"], + ["DECIMAL(10, 2)", "NUMERIC(10,2)"], + ["DOUBLE", "DOUBLE PRECISION", "FLOAT64"], + ["DOUBLE PRECISION(10)", "DOUBLE(10)"], + ["FLOAT64( 38 , 0 )", "FLOAT64(10)", "FLOAT64(10, 2)", "FLOAT64(MAX)"], + ["INT", "integer"], + ["INT(10)", "integer(10)"], + ["INT64( 38 , 0 )", "INT64(10)", "INT64(10,2)", "INT64(MAX)"], + ["LONG", "LONG(10)"], + ["TIMESTAMP", "TIMESTAMP WITHOUT TIME ZONE"], + ["TIMESTAMP WITH TIME ZONE", "TIMESTAMPTZ", "TIMESTAMP_TZ"], + ["TIMESTAMPNTZ", "TIMESTAMPNTZ(0)", "TIMESTAMPNTZ(10)", "TIMESTAMP_NTZ", "TIMESTAMP_NTZ(0)", "TIMESTAMP_NTZ(10)"], + ["TIMESTAMPTZ(10)", "TIMESTAMP_TZ(10)"], + ["TIMESTAMP_LTZ", "TIMESTAMP_LTZ(0)", "TIMESTAMP_LTZ(10)"], + ["character varying", "VARCHAR", "VARCHAR(MAX)"], + ["date", "DATE(10)"], + ["decimal", "NUMERIC"], + ["decimal(10)", "NUMERIC(10)"], + ["timestamptz(0)", "TIMESTAMP_TZ(0)"] + ], + "mssql": [ + ["BIGINT", "INT64"], + ["BOOL", "BOOLEAN"], + ["CHAR", "CHARACTER"], + ["CHAR(10)", "CHARACTER(10)"], + ["CHARACTER VARYING", "VARCHAR"], + ["CHARACTER VARYING(10)", "STRING(10)", "TEXT(10)", "VARCHAR(10)"], + ["DATE", "DATE(10)"], + ["DATETIME", "DATETIME(10)"], + ["DECIMAL", "NUMERIC"], + ["DECIMAL(10)", "NUMERIC(10)"], + ["DECIMAL(10,2)", "NUMERIC(10,2)"], + ["DOUBLE", "DOUBLE PRECISION", "FLOAT"], + ["DOUBLE PRECISION(10)", "DOUBLE(10)", "FLOAT(10)"], + ["FLOAT64(10)", "FLOAT64(10,2)"], + ["INT", "INTEGER"], + ["INT(10)", "INTEGER(10)"], + ["INT64(10)", "INT64(10,2)"], + ["LONG", "LONG(10)"], + ["STRING", "TEXT"], + ["TIMESTAMP", "TIMESTAMP WITHOUT TIME ZONE"], + ["TIMESTAMP WITH TIME ZONE", "TIMESTAMPTZ", "TIMESTAMP_TZ"], + ["TIMESTAMPNTZ", "TIMESTAMPNTZ(10)", "TIMESTAMP_NTZ", "TIMESTAMP_NTZ(10)"], + ["TIMESTAMPTZ(10)", "TIMESTAMP_TZ(10)"], + ["TIMESTAMP_LTZ", "TIMESTAMP_LTZ(10)"] + ], + "postgres": [ + ["ARRAY< FLOAT64(10,2) >", "FLOAT64(10,2) []"], + ["ARRAY< TIMESTAMP_NTZ(0)>", "TIMESTAMPNTZ(0) []"], + ["ARRAY", "DECIMAL(10,2)[]"], + ["ARRAY", "integer[]", "INT[]"], + ["ARRAY", "ARRAY"], + ["BIGINT", "INT64"], + ["BLOB", "bytea"], + ["BOOL", "BOOLEAN", "BOOLEAN(10)"], + ["CHAR", "CHARACTER"], + ["CHAR(10)", "CHARACTER(10)"], + ["CHARACTER VARYING(10)", "string(10)", "TEXT(10)", "VARCHAR(10)"], + ["DATETIME", "DATETIME(0)", "DATETIME(10)"], + ["DECIMAL( 38 , 0 )", "NUMERIC( 38 , 0 )"], + ["DECIMAL(10, 2)", "NUMERIC(10,2)"], + ["DOUBLE", "DOUBLE PRECISION"], + ["DOUBLE PRECISION(10)", "DOUBLE(10)"], + ["FLOAT(10)", "REAL(10)"], + ["FLOAT64( 38 , 0 )", "FLOAT64(10)", "FLOAT64(10, 2)", "FLOAT64(MAX)"], + ["INT", "integer"], + ["INT(10)", "integer(10)"], + ["INT64( 38 , 0 )", "INT64(10)", "INT64(10,2)", "INT64(MAX)"], + ["LONG", "LONG(10)"], + ["SMALLINT", "TINYINT"], + ["SMALLINT(10)", "TINYINT(10)"], + ["STRING", "TEXT"], + ["TIMESTAMP", "TIMESTAMP WITHOUT TIME ZONE"], + ["TIMESTAMP WITH TIME ZONE", "TIMESTAMPTZ", "TIMESTAMP_TZ"], + ["TIMESTAMPNTZ", "TIMESTAMPNTZ(0)", "TIMESTAMPNTZ(10)", "TIMESTAMP_NTZ", "TIMESTAMP_NTZ(0)", "TIMESTAMP_NTZ(10)"], + ["TIMESTAMPTZ(10)", "TIMESTAMP_TZ(10)"], + ["TIMESTAMP_LTZ", "TIMESTAMP_LTZ(0)", "TIMESTAMP_LTZ(10)"], + ["character varying", "VARCHAR", "VARCHAR(MAX)"], + ["date", "DATE(10)"], + ["decimal", "NUMERIC"], + ["decimal(10)", "NUMERIC(10)"], + ["time", "time without time zone"], + ["timestamptz(0)", "TIMESTAMP_TZ(0)"] + ], + "snowflake": [ + ["ARRAY< FLOAT64(10,2) >", "FLOAT64(10,2) []"], + ["ARRAY< TIMESTAMP_NTZ(0)>", "TIMESTAMPNTZ(0) []"], + ["ARRAY", "DECIMAL(10,2)[]"], + ["ARRAY", "INT[]"], + ["ARRAY", "ARRAY"], + ["BIGDECIMAL(10,2)", "bignumeric(10, 2)", "DECIMAL(10, 2)", "NUMBER(10,2)", "NUMERIC(10,2)"], + ["BOOL", "BOOLEAN", "BOOLEAN(10)"], + ["CHAR", "CHARACTER"], + ["CHAR(10)", "CHARACTER(10)"], + ["CHARACTER VARYING(10)", "string(10)", "TEXT(10)", "VARCHAR(10)"], + ["DATETIME", "DATETIME(0)", "DATETIME(10)"], + ["DOUBLE", "DOUBLE PRECISION"], + ["DOUBLE PRECISION(10)", "DOUBLE(10)"], + ["FLOAT", "REAL"], + ["FLOAT(10)", "REAL(10)"], + ["FLOAT64", "FLOAT64( 38 , 0 )", "FLOAT64(10)", "FLOAT64(10, 2)", "FLOAT64(MAX)"], + ["GEOGRAPHY", "GEOGRAPHY(10)"], + ["JSON", "variant"], + ["TIMESTAMP", "TIMESTAMP WITHOUT TIME ZONE", "TIMESTAMPNTZ", "TIMESTAMPNTZ(0)", "TIMESTAMPNTZ(10)", "TIMESTAMP_NTZ", "TIMESTAMP_NTZ(0)", "TIMESTAMP_NTZ(10)", "TIMESTAMP_NTZ(9)"], + ["TIMESTAMP WITH TIME ZONE", "TIMESTAMPTZ", "TIMESTAMP_TZ"], + ["TIMESTAMPTZ(10)", "TIMESTAMP_TZ(10)"], + ["TIMESTAMP_LTZ", "TIMESTAMP_LTZ(0)", "TIMESTAMP_LTZ(10)", "TIMESTAMP_LTZ(9)"], + ["bigdecimal", "BIGDECIMAL( 38 , 0 )", "BIGINT", "BIGINT(10)", "BIGNUMERIC", "BIGNUMERIC( 38 , 0 )", "decimal", "DECIMAL( 38 , 0 )", "INT", "INT(10)", "INT64", "INT64( 38 , 0 )", "INT64(10)", "INT64(10,2)", "INT64(MAX)", "integer", "integer(10)", "LONG", "LONG(10)", "NUMBER", "number( 38 , 0 )", "NUMERIC", "NUMERIC( 38 , 0 )", "SMALLINT", "SMALLINT(10)", "TINYINT", "TINYINT(10)"], + ["bigdecimal(10)", "BIGNUMERIC(10)", "decimal(10)", "NUMBER(10)", "NUMERIC(10)"], + ["character varying", "STRING", "TEXT", "VARCHAR", "VARCHAR(16777216)", "VARCHAR(MAX)"], + ["date", "DATE(10)"], + ["timestamptz(0)", "TIMESTAMP_TZ(0)"] + ], + "sqlite": [ + ["BIGINT", "INT64"], + ["BOOL", "BOOLEAN", "BOOLEAN(10)"], + ["CHAR", "CHARACTER", "CHARACTER VARYING", "TEXT", "VARCHAR"], + ["CHAR(10)", "CHARACTER(10)"], + ["CHARACTER VARYING(10)", "STRING(10)", "TEXT(10)", "VARCHAR(10)"], + ["DATE", "DATE(10)"], + ["DATETIME", "DATETIME(10)"], + ["DECIMAL", "NUMERIC"], + ["DECIMAL(10)", "NUMERIC(10)"], + ["DECIMAL(10,2)", "NUMERIC(10,2)"], + ["DOUBLE", "DOUBLE PRECISION", "REAL"], + ["DOUBLE PRECISION(10)", "DOUBLE(10)", "REAL(10)"], + ["FLOAT64(10)", "FLOAT64(10,2)"], + ["INT", "INTEGER", "SMALLINT", "SMALLINT(10)"], + ["INT(10)", "INTEGER(10)"], + ["INT64(10)", "INT64(10,2)"], + ["LONG", "LONG(10)"], + ["TIMESTAMP", "TIMESTAMP WITHOUT TIME ZONE"], + ["TIMESTAMP WITH TIME ZONE", "TIMESTAMPTZ", "TIMESTAMP_TZ"], + ["TIMESTAMPNTZ", "TIMESTAMPNTZ(10)", "TIMESTAMP_NTZ", "TIMESTAMP_NTZ(10)"], + ["TIMESTAMPTZ(10)", "TIMESTAMP_TZ(10)"], + ["TIMESTAMP_LTZ", "TIMESTAMP_LTZ(10)"] + ], + "tsql": [ + ["ARRAY< DEC( 38 , 0 ) >", "ARRAY< FLOAT64(10,2) >", "ARRAY< TIMESTAMP(10) >", "ARRAY< TIMESTAMP_LTZ>", "ARRAY< TIMESTAMP_NTZ(0)>", "ARRAY>", "ARRAY", "ARRAY", "ARRAY", "ARRAY", "ARRAY", "JSON", "nvarchar(max)"], + ["BIGINT", "INT64"], + ["BOOL", "BOOLEAN"], + ["CHAR", "CHARACTER"], + ["CHAR(10)", "CHARACTER(10)"], + ["CHARACTER VARYING(10)", "string(10)", "TEXT(10)", "VARCHAR(10)"], + ["DATETIME", "DATETIME(0)", "DATETIME(10)"], + ["DECIMAL( 38 , 0 )", "NUMERIC( 38 , 0 )"], + ["DECIMAL(10, 2)", "NUMERIC(10,2)"], + ["DOUBLE", "DOUBLE PRECISION", "FLOAT"], + ["DOUBLE PRECISION(10)", "DOUBLE(10)", "FLOAT(10)"], + ["FLOAT64( 38 , 0 )", "FLOAT64(10)", "FLOAT64(10, 2)", "FLOAT64(MAX)"], + ["INT", "integer"], + ["INT(10)", "integer(10)"], + ["INT64( 38 , 0 )", "INT64(10)", "INT64(10,2)", "INT64(MAX)"], + ["LONG", "LONG(10)"], + ["TIMESTAMP", "TIMESTAMP WITHOUT TIME ZONE"], + ["TIMESTAMP WITH TIME ZONE", "TIMESTAMPTZ", "TIMESTAMP_TZ"], + ["TIMESTAMPNTZ", "TIMESTAMPNTZ(0)", "TIMESTAMPNTZ(10)", "TIMESTAMP_NTZ", "TIMESTAMP_NTZ(0)", "TIMESTAMP_NTZ(10)"], + ["TIMESTAMPTZ(10)", "TIMESTAMP_TZ(10)"], + ["TIMESTAMP_LTZ", "TIMESTAMP_LTZ(0)", "TIMESTAMP_LTZ(10)"], + ["character varying", "VARCHAR", "VARCHAR(MAX)"], + ["date", "DATE(10)"], + ["decimal", "NUMERIC"], + ["decimal(10)", "NUMERIC(10)"], + ["ntext", "STRING", "TEXT"], + ["timestamptz(0)", "TIMESTAMP_TZ(0)"], + ["uniqueidentifier", "UUID"] + ] +} diff --git a/crates/sqlbuild-analysis/src/type_system/tests/helpers.rs b/crates/sqlbuild-analysis/src/type_system/tests/helpers.rs index cc51b6f245..cb6ab068fa 100644 --- a/crates/sqlbuild-analysis/src/type_system/tests/helpers.rs +++ b/crates/sqlbuild-analysis/src/type_system/tests/helpers.rs @@ -1,4 +1,5 @@ -use crate::type_system::models::{PythonInteger, TypeNormalization}; +use crate::type_system::main::normalize_type::normalize_type; +use crate::type_system::models::{NormalizedType, PythonInteger, TypeNormalization}; pub(super) fn normalization_text(normalization: &TypeNormalization) -> String { let optional = @@ -14,3 +15,10 @@ pub(super) fn normalization_text(normalization: &TypeNormalization) -> String { normalization.parse_error.as_deref().unwrap_or("-"), ) } + +/// The normalized type of `type_sql` in `dialect`, which must be a known dialect. +pub(super) fn normalized_type(type_sql: &str, dialect: &str) -> NormalizedType { + normalize_type(type_sql, dialect) + .expect("the dialect is known") + .normalized +} diff --git a/crates/sqlbuild-analysis/src/type_system/tests/test_normalize_type.rs b/crates/sqlbuild-analysis/src/type_system/tests/test_normalize_type.rs index afee3fc479..278b6c7657 100644 --- a/crates/sqlbuild-analysis/src/type_system/tests/test_normalize_type.rs +++ b/crates/sqlbuild-analysis/src/type_system/tests/test_normalize_type.rs @@ -83,20 +83,48 @@ fn given_type_strings_when_normalizing_then_python_normalization_is_returned() { type_sql: "order status", dialect: "generic", expected_normalization: Ok( - "ORDERSTATUS | other | - | - | - | Parse error at line 1, column 13: Unexpected token after data type: status", + "ORDERSTATUS | other | - | - | - | unexpected 'status' after the type", ), }, NormalizeTypeTestCase { - description: "every Polyglot dialect is normalized natively", - type_sql: "INT", - dialect: "mysql", - expected_normalization: Ok("INT | integer | - | - | - | -"), + description: "MotherDuck reads and spells types as DuckDB", + type_sql: "STRUCT(a INT, b VARCHAR(10))[]", + dialect: "motherduck", + expected_normalization: Ok("STRUCT(AINT,BTEXT(10))[] | other | - | - | - | -"), + }, + NormalizeTypeTestCase { + description: "a ClickHouse nested type argument, as cursor types arrive upper-cased", + type_sql: "NULLABLE(DATETIME64(3))", + dialect: "clickhouse", + expected_normalization: Ok("NULLABLE(DATETIME64(3)) | other | - | - | - | -"), + }, + NormalizeTypeTestCase { + description: "a ClickHouse enum member and its value", + type_sql: "ENUM8('a' = 1, 'it''s' = -2)", + dialect: "clickhouse", + expected_normalization: Ok("ENUM8('A'=1,'IT''S'=-2) | other | - | - | - | -"), + }, + NormalizeTypeTestCase { + description: "a ClickHouse named tuple field", + type_sql: "TUPLE(a INT64, b LOWCARDINALITY(NULLABLE(STRING)))", + dialect: "clickhouse", + expected_normalization: Ok( + "TUPLE(AINT64,BLOWCARDINALITY(NULLABLE(STRING))) | other | - | - | - | -", + ), }, NormalizeTypeTestCase { - description: "a dialect Polyglot does not know raises Python's error", + description: "an enum member outside ClickHouse falls back to the text", + type_sql: "ENUM8('a' = 1)", + dialect: "tsql", + expected_normalization: Ok( + "ENUM8('A'=1) | other | - | - | - | unexpected character '''", + ), + }, + NormalizeTypeTestCase { + description: "a dialect no SQLBuild adapter ships raises Python's error", type_sql: "INT", - dialect: "motherduck", - expected_normalization: Err("Unknown dialect: motherduck"), + dialect: "mysql", + expected_normalization: Err("Unknown dialect: mysql"), }, NormalizeTypeTestCase { description: "non-ASCII text upper-cases with Python's Unicode mapping", @@ -110,7 +138,8 @@ fn given_type_strings_when_normalizing_then_python_normalization_is_returned() { dialect: "duckdb", expected_normalization: Ok( "DECIMAL(99999999999999999999,2) | decimal | 99999999999999999999 | 2 | - | \ - Parse error at line 1, column 30: Invalid number: 99999999999999999999", + Parse(Parse { message: \"Invalid number: 99999999999999999999\", line: 1, \ + column: 50, start: 48, end: 49 })", ), }, NormalizeTypeTestCase { @@ -118,7 +147,8 @@ fn given_type_strings_when_normalizing_then_python_normalization_is_returned() { type_sql: "VARCHAR(\u{663})", dialect: "snowflake", expected_normalization: Ok( - "VARCHAR(3) | string | - | - | 3 | Parse error at line 1, column 10: Expected number", + "VARCHAR(3) | string | - | - | 3 | Parse(Parse { message: \"Expected number\", \ + line: 1, column: 30, start: 28, end: 29 })", ), }, ]; diff --git a/crates/sqlbuild-analysis/src/type_system/tests/test_same_type.rs b/crates/sqlbuild-analysis/src/type_system/tests/test_same_type.rs index c97bf25c73..52f84e5e99 100644 --- a/crates/sqlbuild-analysis/src/type_system/tests/test_same_type.rs +++ b/crates/sqlbuild-analysis/src/type_system/tests/test_same_type.rs @@ -1,9 +1,15 @@ +use std::collections::BTreeMap; + use crate::type_system::main::normalize_type::normalize_type; use crate::type_system::main::same_type::same_type; -use crate::type_system::tests::test_types::SameTypeTestCase; +use crate::type_system::tests::helpers::normalized_type; +use crate::type_system::tests::test_types::{AliasGroupsTestCase, SameTypeTestCase}; + +/// Each dialect's groups of valid spellings that the Polyglot-based normalization read alike. +const ALIAS_GROUPS: &str = include_str!("alias_groups.json"); #[test] -fn given_two_types_when_comparing_then_an_unstated_snowflake_temporal_precision_matches() { +fn given_two_types_when_comparing_then_same_type_answers() { let test_cases = [ SameTypeTestCase { description: "a declared millisecond time matches metadata's precision-less time", @@ -65,6 +71,24 @@ fn given_two_types_when_comparing_then_an_unstated_snowflake_temporal_precision_ types: ("VARCHAR(10)", "VARCHAR(20)"), expected_same: false, }, + SameTypeTestCase { + description: "Postgres FLOAT without a precision is DOUBLE PRECISION, not REAL", + dialect: "postgres", + types: ("FLOAT", "REAL"), + expected_same: false, + }, + SameTypeTestCase { + description: "BigQuery's TIMESTAMP is an absolute time, not a civil DATETIME", + dialect: "bigquery", + types: ("TIMESTAMP", "TIMESTAMP WITHOUT TIME ZONE"), + expected_same: false, + }, + SameTypeTestCase { + description: "BigQuery's civil time is DATETIME", + dialect: "bigquery", + types: ("DATETIME", "TIMESTAMP WITHOUT TIME ZONE"), + expected_same: true, + }, ]; for test_case in test_cases { let (left, right) = test_case.types; @@ -82,3 +106,34 @@ fn given_two_types_when_comparing_then_an_unstated_snowflake_temporal_precision_ ); } } + +#[test] +fn given_spellings_of_one_type_when_comparing_then_every_pair_is_the_same_type() { + let test_cases = [AliasGroupsTestCase { + description: "every alias group of the Polyglot-based normalization", + groups: ALIAS_GROUPS, + expected_same: true, + }]; + for test_case in test_cases { + let groups: BTreeMap>> = + serde_json::from_str(test_case.groups).expect("the alias groups are JSON"); + for (dialect, dialect_groups) in &groups { + for group in dialect_groups { + for (index, left) in group.iter().enumerate() { + for right in &group[index + 1..] { + assert_eq!( + same_type( + &normalized_type(left, dialect), + &normalized_type(right, dialect), + dialect, + ), + test_case.expected_same, + "{}: {dialect} `{left}` and `{right}`", + test_case.description + ); + } + } + } + } + } +} diff --git a/crates/sqlbuild-analysis/src/type_system/tests/test_types.rs b/crates/sqlbuild-analysis/src/type_system/tests/test_types.rs index 2b9aeec95d..b678a56f7f 100644 --- a/crates/sqlbuild-analysis/src/type_system/tests/test_types.rs +++ b/crates/sqlbuild-analysis/src/type_system/tests/test_types.rs @@ -30,3 +30,10 @@ pub(super) struct SameTypeTestCase { pub(super) types: (&'static str, &'static str), pub(super) expected_same: bool, } + +pub(super) struct AliasGroupsTestCase { + pub(super) description: &'static str, + /// JSON: each dialect's groups of spellings of one type. + pub(super) groups: &'static str, + pub(super) expected_same: bool, +} diff --git a/crates/sqlbuild-analysis/src/warehouse_types/_helpers/mod.rs b/crates/sqlbuild-analysis/src/warehouse_types/_helpers/mod.rs new file mode 100644 index 0000000000..b0d2d9639d --- /dev/null +++ b/crates/sqlbuild-analysis/src/warehouse_types/_helpers/mod.rs @@ -0,0 +1 @@ +pub(crate) mod type_trees; diff --git a/crates/sqlbuild-analysis/src/warehouse_types/_helpers/type_trees.rs b/crates/sqlbuild-analysis/src/warehouse_types/_helpers/type_trees.rs new file mode 100644 index 0000000000..6a810dcfc0 --- /dev/null +++ b/crates/sqlbuild-analysis/src/warehouse_types/_helpers/type_trees.rs @@ -0,0 +1,67 @@ +//! Type trees from SQLQuack's parsers: Postgres's type grammar, or a cast target's type. + +use serde_json::Value; +use sqlquack_syntax::tokens::models::Dialect; +use sqlquack_syntax::{Expression, ParseOptions, parse_strict}; + +use crate::warehouse_types::constants::{CAST_KEY, CAST_TARGET_KEY}; + +/// `spelling` read by `sqlquack-syntax-postgres`'s type grammar. +pub(crate) fn postgres_type(spelling: &str) -> Result { + let data_type = + sqlquack_syntax_postgres::parse_type(spelling).map_err(|error| format!("{error:?}"))?; + serde_json::to_value(data_type).map_err(|error| error.to_string()) +} + +/// `spelling` read as a cast target by SQLQuack's core parser for `dialect`. +pub(crate) fn core_type(spelling: &str, dialect: Dialect) -> Result { + let statements: Vec = + parse_strict(&cast(spelling), dialect, &ParseOptions::default()) + .map_err(|error| format!("{error:?}"))?; + single_cast_target(spelling, &statements) +} + +/// `spelling` read as a cast target by `sqlquack-syntax-bigquery`. +pub(crate) fn bigquery_type(spelling: &str) -> Result { + let statements: Vec = sqlquack_syntax_bigquery::parse_strict(&cast(spelling)) + .map_err(|error| format!("{error:?}"))? + .statements; + single_cast_target(spelling, &statements) +} + +/// A statement that casts NULL to `spelling`. +fn cast(spelling: &str) -> String { + format!("SELECT CAST(NULL AS {spelling})") +} + +/// The target type of the one cast in the one statement, or why `spelling` is not one type. +fn single_cast_target(spelling: &str, statements: &[Expression]) -> Result { + let tree: Value = serde_json::to_value(statements).map_err(|error| error.to_string())?; + match (statements.len(), cast_targets(&tree).as_slice()) { + (1, [target]) => Ok((*target).clone()), + _ => Err(format!("`{spelling}` is not a single type name")), + } +} + +/// Every cast's target type in `tree`, in order. +fn cast_targets(tree: &Value) -> Vec<&Value> { + let mut targets: Vec<&Value> = Vec::new(); + let mut pending: Vec<&Value> = vec![tree]; + while let Some(node) = pending.pop() { + match node { + Value::Object(fields) => { + for (key, value) in fields.iter().rev() { + pending.push(value); + if key == CAST_KEY + && let Some(target) = value.get(CAST_TARGET_KEY) + { + targets.push(target); + } + } + } + Value::Array(items) => pending.extend(items.iter().rev()), + _ => {} + } + } + targets +} diff --git a/crates/sqlbuild-analysis/src/warehouse_types/main/mod.rs b/crates/sqlbuild-analysis/src/warehouse_types/main/mod.rs index fdbebafce0..5d33207517 100644 --- a/crates/sqlbuild-analysis/src/warehouse_types/main/mod.rs +++ b/crates/sqlbuild-analysis/src/warehouse_types/main/mod.rs @@ -1 +1,2 @@ pub mod parse_warehouse_type; +pub mod type_tree; diff --git a/crates/sqlbuild-analysis/src/warehouse_types/main/parse_warehouse_type.rs b/crates/sqlbuild-analysis/src/warehouse_types/main/parse_warehouse_type.rs index dc6682be9a..4128082fb4 100644 --- a/crates/sqlbuild-analysis/src/warehouse_types/main/parse_warehouse_type.rs +++ b/crates/sqlbuild-analysis/src/warehouse_types/main/parse_warehouse_type.rs @@ -2,58 +2,17 @@ use serde_json::Value; use sqlquack_syntax::tokens::models::Dialect; -use sqlquack_syntax::{Expression, ParseOptions, parse_strict}; -use crate::warehouse_types::constants::{ - BIGQUERY_DIALECT, CAST_KEY, CAST_TARGET_KEY, POSTGRES_DIALECT, SNOWFLAKE_DIALECT, -}; +use crate::warehouse_types::constants::{BIGQUERY_DIALECT, POSTGRES_DIALECT, SNOWFLAKE_DIALECT}; +use crate::warehouse_types::main::type_tree::type_tree; +use crate::warehouse_types::models::TypeParser; /// The type tree of `spelling` in `dialect`, None without a parser, or why the parser rejects it. pub fn parse_warehouse_type(spelling: &str, dialect: &str) -> Result, String> { - let cast: String = format!("SELECT CAST(NULL AS {spelling})"); - let statements: Vec = match dialect { - POSTGRES_DIALECT => { - let data_type = sqlquack_syntax_postgres::parse_type(spelling) - .map_err(|error| format!("{error:?}"))?; - return serde_json::to_value(data_type) - .map(Some) - .map_err(|error| error.to_string()); - } - SNOWFLAKE_DIALECT => parse_strict(&cast, Dialect::Snowflake, &ParseOptions::default()) - .map_err(|error| format!("{error:?}"))?, - BIGQUERY_DIALECT => { - sqlquack_syntax_bigquery::parse_strict(&cast) - .map_err(|error| format!("{error:?}"))? - .statements - } - _ => return Ok(None), - }; - let tree: Value = serde_json::to_value(&statements).map_err(|error| error.to_string())?; - match (statements.len(), cast_targets(&tree).as_slice()) { - (1, [target]) => Ok(Some((*target).clone())), - _ => Err(format!("`{spelling}` is not a single type name")), + match dialect { + POSTGRES_DIALECT => type_tree(spelling, TypeParser::Postgres).map(Some), + SNOWFLAKE_DIALECT => type_tree(spelling, TypeParser::Core(Dialect::Snowflake)).map(Some), + BIGQUERY_DIALECT => type_tree(spelling, TypeParser::BigQuery).map(Some), + _ => Ok(None), } } - -/// Every cast's target type in `tree`, in order. -fn cast_targets(tree: &Value) -> Vec<&Value> { - let mut targets: Vec<&Value> = Vec::new(); - let mut pending: Vec<&Value> = vec![tree]; - while let Some(node) = pending.pop() { - match node { - Value::Object(fields) => { - for (key, value) in fields.iter().rev() { - pending.push(value); - if key == CAST_KEY - && let Some(target) = value.get(CAST_TARGET_KEY) - { - targets.push(target); - } - } - } - Value::Array(items) => pending.extend(items.iter().rev()), - _ => {} - } - } - targets -} diff --git a/crates/sqlbuild-analysis/src/warehouse_types/main/type_tree.rs b/crates/sqlbuild-analysis/src/warehouse_types/main/type_tree.rs new file mode 100644 index 0000000000..cfa9c12309 --- /dev/null +++ b/crates/sqlbuild-analysis/src/warehouse_types/main/type_tree.rs @@ -0,0 +1,15 @@ +//! `type_tree`: a type name as one of SQLQuack's parsers reads it. + +use serde_json::Value; + +use crate::warehouse_types::_helpers::type_trees::{bigquery_type, core_type, postgres_type}; +use crate::warehouse_types::models::TypeParser; + +/// The type tree `parser` reads from `spelling`, or why it rejects it. +pub fn type_tree(spelling: &str, parser: TypeParser) -> Result { + match parser { + TypeParser::Postgres => postgres_type(spelling), + TypeParser::BigQuery => bigquery_type(spelling), + TypeParser::Core(dialect) => core_type(spelling, dialect), + } +} diff --git a/crates/sqlbuild-analysis/src/warehouse_types/mod.rs b/crates/sqlbuild-analysis/src/warehouse_types/mod.rs index c0ebb26c0f..8e1b42f6e3 100644 --- a/crates/sqlbuild-analysis/src/warehouse_types/mod.rs +++ b/crates/sqlbuild-analysis/src/warehouse_types/mod.rs @@ -1,4 +1,6 @@ //! Warehouse column type names as SQLQuack's parser for each warehouse dialect reads them. +pub(crate) mod _helpers; pub(crate) mod constants; pub mod main; +pub mod models; diff --git a/crates/sqlbuild-analysis/src/warehouse_types/models.rs b/crates/sqlbuild-analysis/src/warehouse_types/models.rs new file mode 100644 index 0000000000..8fb7d377e6 --- /dev/null +++ b/crates/sqlbuild-analysis/src/warehouse_types/models.rs @@ -0,0 +1,14 @@ +//! The SQLQuack parsers that read warehouse type names. + +use sqlquack_syntax::tokens::models::Dialect; + +/// Which SQLQuack parser reads a type name. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum TypeParser { + /// `sqlquack-syntax-postgres`'s type grammar. + Postgres, + /// A cast target read by `sqlquack-syntax-bigquery`. + BigQuery, + /// A cast target read by SQLQuack's core parser for the dialect. + Core(Dialect), +} diff --git a/crates/sqlbuild-python/src/bindings/_helpers/contracts/model_contracts.rs b/crates/sqlbuild-python/src/bindings/_helpers/contracts/model_contracts.rs index b7ef9cdd1b..99d744dae5 100644 --- a/crates/sqlbuild-python/src/bindings/_helpers/contracts/model_contracts.rs +++ b/crates/sqlbuild-python/src/bindings/_helpers/contracts/model_contracts.rs @@ -51,7 +51,7 @@ pub(crate) fn evaluate_project_model_contracts( .compiler_detach(|| Ok(evaluate_model_contracts(&request))) .map_err(compiler_error)?; let outcomes: Vec> = - outcomes.map_err(|error| normalization_error(py, &error))?; + outcomes.map_err(|error| normalization_error(&error))?; Ok(models .iter() .zip(outcomes) diff --git a/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/completion.rs b/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/completion.rs index fc4d785cc2..8fdb86fd0a 100644 --- a/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/completion.rs +++ b/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/completion.rs @@ -66,7 +66,7 @@ pub(crate) fn completed_diagnostics<'py>( let (completed, model_bindings, order) = py .compiler_detach(|| Ok(complete_semantic_diagnostics(&request, shared.catalog))) .map_err(compiler_error)? - .map_err(|failure| semantic_error(py, &failure))? + .map_err(|failure| semantic_error(&failure))? .into_parts(); let mut rebuilt: Vec> = Vec::with_capacity(completed.len()); for row in completed { diff --git a/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/failures.rs b/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/failures.rs index 8535b64c6c..486267e427 100644 --- a/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/failures.rs +++ b/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/failures.rs @@ -1,7 +1,7 @@ //! The exception a failed native semantic completion step raises. +use pyo3::PyErr; use pyo3::exceptions::{PyTypeError, PyValueError}; -use pyo3::{PyErr, Python}; use sqlbuild_analysis::semantic_checks::models::SemanticFailure; use sqlbuild_core::constants::PANIC_MESSAGE; use sqlbuild_core::panics::main::is_compiler_panic::is_compiler_panic; @@ -15,13 +15,13 @@ const SEMANTIC_CONTEXT: &str = "native semantic completion"; const NO_DIALECT_MESSAGE: &str = "argument 'dialect': 'None' is not an instance of 'str'"; /// The error Python's semantic completion raised for the same input, or `NativeCompilerError`. -pub(crate) fn semantic_error(python: Python<'_>, failure: &SemanticFailure) -> PyErr { +pub(crate) fn semantic_error(failure: &SemanticFailure) -> PyErr { match failure { SemanticFailure::NoDialect => PyTypeError::new_err(NO_DIALECT_MESSAGE), SemanticFailure::UnknownDialect(name) => { PyValueError::new_err(format!("Unknown dialect: {name}")) } - SemanticFailure::TypeNormalization(error) => normalization_error(python, error), + SemanticFailure::TypeNormalization(error) => normalization_error(error), SemanticFailure::Internal(reason) => internal_error(reason), } } diff --git a/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/metadata.rs b/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/metadata.rs index 422162374f..629a05e747 100644 --- a/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/metadata.rs +++ b/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/metadata.rs @@ -70,7 +70,7 @@ pub(crate) fn metadata_diagnostics<'py>( let outcome = py .compiler_detach(|| Ok(check_semantic_metadata(&request, catalog))) .map_err(compiler_error)? - .map_err(|failure| semantic_error(py, &failure))?; + .map_err(|failure| semantic_error(&failure))?; let dialect: Bound<'py, PyAny> = native_field(profile, "sql_analysis_dialect")?; for type_sql in &outcome.fallback_types { let _ = classes.call( diff --git a/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/type_recovery.rs b/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/type_recovery.rs index c75a2b2af4..eddbc4fc81 100644 --- a/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/type_recovery.rs +++ b/crates/sqlbuild-python/src/bindings/_helpers/semantic_checks/type_recovery.rs @@ -93,7 +93,7 @@ pub(crate) fn recovered_types<'py>( let step = py .compiler_detach(|| Ok(plan_type_recovery(&request, shared.catalog))) .map_err(compiler_error)? - .map_err(|failure| semantic_error(py, &failure))?; + .map_err(|failure| semantic_error(&failure))?; if step.status() == UNCHANGED { return Ok(project.clone()); } diff --git a/crates/sqlbuild-python/src/bindings/_helpers/type_system/equality.rs b/crates/sqlbuild-python/src/bindings/_helpers/type_system/equality.rs index 125c688b3c..805d5de931 100644 --- a/crates/sqlbuild-python/src/bindings/_helpers/type_system/equality.rs +++ b/crates/sqlbuild-python/src/bindings/_helpers/type_system/equality.rs @@ -16,7 +16,7 @@ use crate::bindings::_helpers::native_host::host; use crate::bindings::_helpers::type_system::normalization::normalization_error; const TYPE_NORMALIZATION_LOGGER: &str = "sqlbuild.adapter"; -const TYPE_PARSE_FALLBACK_MESSAGE: &str = "type normalization polyglot parse failed; falling back"; +const TYPE_PARSE_FALLBACK_MESSAGE: &str = "type normalization parse failed; falling back"; const DEFAULT_DIALECT: &str = "generic"; const CACHE_LIMIT: usize = 1024; @@ -37,7 +37,6 @@ pub(crate) fn types_equal(dialect: &Bound<'_, PyAny>, left: &str, right: &str) - } fn normalized(dialect: &Bound<'_, PyAny>, name: &str, type_sql: &str) -> PyResult { - let py: Python<'_> = dialect.py(); let cache: &Cache = NORMALIZED.get_or_init(|| Mutex::new(HashMap::new())); let key: (String, String) = (type_sql.to_owned(), name.to_owned()); let cached: Option = cache @@ -52,7 +51,7 @@ fn normalized(dialect: &Bound<'_, PyAny>, name: &str, type_sql: &str) -> PyResul normalized, parse_error, } = compiler_guard(|| Ok(normalize_type(type_sql, name)))? - .map_err(|error| normalization_error(py, &error))?; + .map_err(|error| normalization_error(&error))?; if let Some(parse_error) = parse_error { log_parse_fallback(dialect, type_sql, &parse_error)?; } diff --git a/crates/sqlbuild-python/src/bindings/_helpers/type_system/normalization.rs b/crates/sqlbuild-python/src/bindings/_helpers/type_system/normalization.rs index 74fe591603..3193722270 100644 --- a/crates/sqlbuild-python/src/bindings/_helpers/type_system/normalization.rs +++ b/crates/sqlbuild-python/src/bindings/_helpers/type_system/normalization.rs @@ -1,14 +1,13 @@ //! Native type normalization. use pyo3::exceptions::PyValueError; -use pyo3::prelude::{Bound, PyAnyMethods, PyErr, PyModule, PyModuleMethods, PyResult, Python}; +use pyo3::prelude::{Bound, PyErr, PyModule, PyModuleMethods, PyResult}; use pyo3::{pyfunction, wrap_pyfunction}; use sqlbuild_analysis::type_system::errors::TypeNormalizationError; use sqlbuild_analysis::type_system::main::normalize_type::normalize_type; use sqlbuild_analysis::type_system::models::{NormalizedType, TypeNormalization}; use crate::bindings::_helpers::boundary::panics::compiler_guard; -use crate::bindings::_helpers::records::fields::field as native_field; positional_record! { into; @@ -22,11 +21,10 @@ positional_record! { } } -/// Normalize one type: `(normalized row, Polyglot parse error)`, or Python's exception. +/// Normalize one type: `(normalized row, parse error)`, or Python's exception. #[pyfunction] #[pyo3(name = "normalize_type")] fn normalize_type_binding( - python: Python<'_>, type_sql: &str, dialect: &str, ) -> PyResult<(NormalizedRow, Option)> { @@ -37,20 +35,13 @@ fn normalize_type_binding( normalized, parse_error, }) => Ok((normalized_row(normalized), parse_error)), - Err(error) => Err(normalization_error(python, &error)), + Err(error) => Err(normalization_error(&error)), } } -/// The exception the Polyglot wheel raises for the same failure. -pub(crate) fn normalization_error(python: Python<'_>, error: &TypeNormalizationError) -> PyErr { - match error { - TypeNormalizationError::UnknownDialect(_) => PyValueError::new_err(error.message()), - TypeNormalizationError::Generation(_) => python - .import("polyglot_sql") - .and_then(|module| native_field(&module, "PolyglotError")) - .and_then(|class| class.call1((error.message(),))) - .map_or_else(|import_error| import_error, PyErr::from_value), - } +/// Python's exception for a type that cannot be normalized. +pub(crate) fn normalization_error(error: &TypeNormalizationError) -> PyErr { + PyValueError::new_err(error.message()) } fn normalized_row(normalized: NormalizedType) -> NormalizedRow { diff --git a/fensu.toml b/fensu.toml index bf5365df88..7f0ef427f5 100644 --- a/fensu.toml +++ b/fensu.toml @@ -2440,7 +2440,7 @@ pending_budgets = [ "crates/sqlbuild-python/src/bindings/_helpers/state_rows/state_tables.rs=1", "crates/sqlbuild-python/src/bindings/_helpers/state_rows/timestamps.rs=4", "crates/sqlbuild-python/src/bindings/_helpers/type_system/equality.rs=3", - "crates/sqlbuild-python/src/bindings/_helpers/type_system/normalization.rs=2", + "crates/sqlbuild-python/src/bindings/_helpers/type_system/normalization.rs=0", "crates/sqlbuild-python/src/bindings/_helpers/workspace_commands/commands.rs=5", "crates/sqlbuild-python/src/bindings/models.rs=0", ] @@ -2934,5 +2934,5 @@ path = "src/sqlbuild/orchestration_declarations/models/sensor_context.py" reason = "Only SensorContext lives here: invocation-local ctx.cursor assignment proposes progress, committed solely by native fenced completion. The package regression guards this declaration-only scope; class-symbol exceptions are unsupported." [[dupes.allowlist]] -paths = ["crates/sqlbuild-analysis/src/warehouse_types/main/parse_warehouse_type.rs", "crates/sqlbuild-analysis/src/assembly/analysis_session/_helpers/dict_walk.rs", "crates/sqlbuild-analysis/src/relation_names/_helpers/walk.rs"] +paths = ["crates/sqlbuild-analysis/src/warehouse_types/_helpers/type_trees.rs", "crates/sqlbuild-analysis/src/assembly/analysis_session/_helpers/dict_walk.rs", "crates/sqlbuild-analysis/src/relation_names/_helpers/walk.rs"] reason = "Each is a short stack walk over a JSON syntax tree with its own stop and collect rule: cast_targets collects every cast's target type, branch_selects stops at each set-operation branch, and walked lists every object. A shared visitor would need a callback for each rule and save no logic." diff --git a/src/sqlbuild/adapter/type_system/constants.py b/src/sqlbuild/adapter/type_system/constants.py index 345fe35380..83af16becc 100644 --- a/src/sqlbuild/adapter/type_system/constants.py +++ b/src/sqlbuild/adapter/type_system/constants.py @@ -1,4 +1,4 @@ """Logging names shared by the Python and native type normalization.""" TYPE_NORMALIZATION_LOGGER_NAME: str = "sqlbuild.adapter" -TYPE_PARSE_FALLBACK_MESSAGE: str = "type normalization polyglot parse failed; falling back" +TYPE_PARSE_FALLBACK_MESSAGE: str = "type normalization parse failed; falling back" diff --git a/src/sqlbuild/adapter/type_system/main/_native_normalize_type.py b/src/sqlbuild/adapter/type_system/main/_native_normalize_type.py index 77f1c5d714..97882418d7 100644 --- a/src/sqlbuild/adapter/type_system/main/_native_normalize_type.py +++ b/src/sqlbuild/adapter/type_system/main/_native_normalize_type.py @@ -15,7 +15,7 @@ def normalize_native_type(*, type_sql: str, dialect: TypeDialect | str | None) -> NormalizedType: - """Return the native normalization of one type, raising as Polyglot does.""" + """Return the native normalization of one type, raising ValueError for an unknown dialect.""" (normalized_name, family, precision, scale, length), parse_error = _native.normalize_type( type_sql, str(dialect or "generic") diff --git a/tests/goldens/python_oracle/contracts_generated_enforced_implicit_typed_nullability_and_dynamic_contracts.json b/tests/goldens/python_oracle/contracts_generated_enforced_implicit_typed_nullability_and_dynamic_contracts.json index 06b2d6254c..ef13a2abfb 100644 --- a/tests/goldens/python_oracle/contracts_generated_enforced_implicit_typed_nullability_and_dynamic_contracts.json +++ b/tests/goldens/python_oracle/contracts_generated_enforced_implicit_typed_nullability_and_dynamic_contracts.json @@ -426,7 +426,7 @@ "bigquery": "0fb1be349cccda275d77113d", "databricks": "0fb1be349cccda275d77113d", "duckdb": "0fb1be349cccda275d77113d", -"postgres": "0fb1be349cccda275d77113d", +"postgres": "a281bca2dfa9d33402e687f3", "snowflake": "0fb1be349cccda275d77113d", "tsql": "0fb1be349cccda275d77113d" } @@ -594,7 +594,7 @@ "bigquery": "6e5f3057275c88687658bb88", "databricks": "6e5f3057275c88687658bb88", "duckdb": "6e5f3057275c88687658bb88", -"postgres": "6e5f3057275c88687658bb88", +"postgres": "2a42e291118d5fa419ada6b8", "snowflake": "6e5f3057275c88687658bb88", "tsql": "6e5f3057275c88687658bb88" } diff --git a/tests/goldens/python_oracle/metadata_formerly_deferred_non_ascii_names_and_comments_new_and_unknown_dialects.json b/tests/goldens/python_oracle/metadata_formerly_deferred_non_ascii_names_and_comments_new_and_unknown_dialects.json index c1e0c0cba7..ca4fc48fe6 100644 --- a/tests/goldens/python_oracle/metadata_formerly_deferred_non_ascii_names_and_comments_new_and_unknown_dialects.json +++ b/tests/goldens/python_oracle/metadata_formerly_deferred_non_ascii_names_and_comments_new_and_unknown_dialects.json @@ -3,8 +3,8 @@ "metadata", { "None": "257eadf2980dd54d687bb376", +"clickhouse": "e9bb705b46de595b24a50b7d", "duckdb": "d1d66a9dd0325471cc034afd", -"mysql": "257eadf2980dd54d687bb376", "nonsense": "6f6079f31e12e028922d40f2", "tsql": "257eadf2980dd54d687bb376" } @@ -13,8 +13,8 @@ "metadata", { "None": "c9f66e2829627aeb5e4728db", +"clickhouse": "c9f66e2829627aeb5e4728db", "duckdb": "0ed0773a2a4a6fca23c1dcac", -"mysql": "c9f66e2829627aeb5e4728db", "nonsense": "6f6079f31e12e028922d40f2", "tsql": "c9f66e2829627aeb5e4728db" } @@ -23,8 +23,8 @@ "metadata", { "None": "a86fc9ef8fd7f46e7110dff4", +"clickhouse": "a86fc9ef8fd7f46e7110dff4", "duckdb": "30c78fd5afb3d05479d6c4ca", -"mysql": "a86fc9ef8fd7f46e7110dff4", "nonsense": "6f6079f31e12e028922d40f2", "tsql": "a86fc9ef8fd7f46e7110dff4" } @@ -33,8 +33,8 @@ "metadata", { "None": "9225fd40168382c4100e98c3", +"clickhouse": "9225fd40168382c4100e98c3", "duckdb": "55da090c1795767af58252eb", -"mysql": "9225fd40168382c4100e98c3", "nonsense": "6f6079f31e12e028922d40f2", "tsql": "9225fd40168382c4100e98c3" } diff --git a/tests/goldens/python_oracle/semantic_formerly_deferred_dialects_added_to_the_native_parser_build.json b/tests/goldens/python_oracle/semantic_formerly_deferred_dialects_added_to_the_native_parser_build.json index 64b357cbe9..74d44ab9a3 100644 --- a/tests/goldens/python_oracle/semantic_formerly_deferred_dialects_added_to_the_native_parser_build.json +++ b/tests/goldens/python_oracle/semantic_formerly_deferred_dialects_added_to_the_native_parser_build.json @@ -2,22 +2,18 @@ [ "completion", { +"clickhouse": "25140233ccf8e7760c91ffd6", "databricks": "25140233ccf8e7760c91ffd6", -"mysql": "25140233ccf8e7760c91ffd6", -"oracle": "25140233ccf8e7760c91ffd6", "sqlite": "25140233ccf8e7760c91ffd6", -"trino": "25140233ccf8e7760c91ffd6", "tsql": "25140233ccf8e7760c91ffd6" } ], [ "completion", { +"clickhouse": "edd3b1ec05f9481067078045", "databricks": "edd3b1ec05f9481067078045", -"mysql": "edd3b1ec05f9481067078045", -"oracle": "edd3b1ec05f9481067078045", "sqlite": "edd3b1ec05f9481067078045", -"trino": "edd3b1ec05f9481067078045", "tsql": "edd3b1ec05f9481067078045" } ] diff --git a/tests/goldens/python_oracle/types_generated_seeded_scalar_parameterized_nested_padded_and_invalid_types.json b/tests/goldens/python_oracle/types_generated_seeded_scalar_parameterized_nested_padded_and_invalid_types.json index 1729e43aef..f2b91b5ff9 100644 --- a/tests/goldens/python_oracle/types_generated_seeded_scalar_parameterized_nested_padded_and_invalid_types.json +++ b/tests/goldens/python_oracle/types_generated_seeded_scalar_parameterized_nested_padded_and_invalid_types.json @@ -8,8 +8,8 @@ "databricks": "7e163d1c3f6840b5164def94", "duckdb": "7e163d1c3f6840b5164def94", "generic": "7e163d1c3f6840b5164def94", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7e163d1c3f6840b5164def94", +"motherduck": "7e163d1c3f6840b5164def94", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7e163d1c3f6840b5164def94", "postgresql": "7e163d1c3f6840b5164def94", "snowflake": "7e163d1c3f6840b5164def94", @@ -25,8 +25,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -42,10 +42,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -59,8 +59,8 @@ "databricks": "e6badc927d1adf4563b4f3a5", "duckdb": "e6badc927d1adf4563b4f3a5", "generic": "e6badc927d1adf4563b4f3a5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e6badc927d1adf4563b4f3a5", +"motherduck": "e6badc927d1adf4563b4f3a5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e6badc927d1adf4563b4f3a5", "postgresql": "e6badc927d1adf4563b4f3a5", "snowflake": "e6badc927d1adf4563b4f3a5", @@ -76,8 +76,8 @@ "databricks": "bbb2563edda71d0b69ef0855", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "bbb2563edda71d0b69ef0855", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "51d717b08676179ee1ccefe4", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "bbb2563edda71d0b69ef0855", "postgresql": "bbb2563edda71d0b69ef0855", "snowflake": "bbb2563edda71d0b69ef0855", @@ -93,8 +93,8 @@ "databricks": "688179272da645629077e980", "duckdb": "688179272da645629077e980", "generic": "688179272da645629077e980", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "688179272da645629077e980", +"motherduck": "688179272da645629077e980", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "688179272da645629077e980", "postgresql": "688179272da645629077e980", "snowflake": "b210f8eb26c37b422f786c6b", @@ -110,8 +110,8 @@ "databricks": "0703bf71a54942bdaa28406e", "duckdb": "0703bf71a54942bdaa28406e", "generic": "0703bf71a54942bdaa28406e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0703bf71a54942bdaa28406e", +"motherduck": "0703bf71a54942bdaa28406e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0703bf71a54942bdaa28406e", "postgresql": "0703bf71a54942bdaa28406e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -122,34 +122,34 @@ "type", { "DuckDB": "5c8b98f516cedefc237fa721", -"None": "5c8b98f516cedefc237fa721", -"bigquery": "5c8b98f516cedefc237fa721", -"databricks": "5c8b98f516cedefc237fa721", +"None": "81a45386abae5f6be0a027d0", +"bigquery": "09b7f1f9111bc2e0767cc059", +"databricks": "81a45386abae5f6be0a027d0", "duckdb": "5c8b98f516cedefc237fa721", -"generic": "5c8b98f516cedefc237fa721", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c8b98f516cedefc237fa721", +"generic": "81a45386abae5f6be0a027d0", +"motherduck": "5c8b98f516cedefc237fa721", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5c8b98f516cedefc237fa721", "postgresql": "5c8b98f516cedefc237fa721", "snowflake": "5c8b98f516cedefc237fa721", -"tsql": "5c8b98f516cedefc237fa721" +"tsql": "81a45386abae5f6be0a027d0" } ], [ "type", { -"DuckDB": "d00038134428e2ce04bc8e09", -"None": "ab7940999dc6f4c634249230", -"bigquery": "ab7940999dc6f4c634249230", -"databricks": "ab7940999dc6f4c634249230", -"duckdb": "d00038134428e2ce04bc8e09", -"generic": "ab7940999dc6f4c634249230", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ab7940999dc6f4c634249230", -"postgres": "ab7940999dc6f4c634249230", -"postgresql": "ab7940999dc6f4c634249230", -"snowflake": "d00038134428e2ce04bc8e09", -"tsql": "ab7940999dc6f4c634249230" +"DuckDB": "6f9bc04f2e8c71a032255bac", +"None": "9ae2060b9503b8d23efaa736", +"bigquery": "9ae2060b9503b8d23efaa736", +"databricks": "9ae2060b9503b8d23efaa736", +"duckdb": "6f9bc04f2e8c71a032255bac", +"generic": "9ae2060b9503b8d23efaa736", +"motherduck": "6f9bc04f2e8c71a032255bac", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9ae2060b9503b8d23efaa736", +"postgresql": "9ae2060b9503b8d23efaa736", +"snowflake": "6f9bc04f2e8c71a032255bac", +"tsql": "9ae2060b9503b8d23efaa736" } ], [ @@ -161,8 +161,8 @@ "databricks": "ee1b4ffc65518c536e3632ee", "duckdb": "ee1b4ffc65518c536e3632ee", "generic": "ee1b4ffc65518c536e3632ee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ee1b4ffc65518c536e3632ee", +"motherduck": "ee1b4ffc65518c536e3632ee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ee1b4ffc65518c536e3632ee", "postgresql": "ee1b4ffc65518c536e3632ee", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -178,8 +178,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -191,12 +191,12 @@ { "DuckDB": "0f799a95a4f5ef502897f02c", "None": "0f799a95a4f5ef502897f02c", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "0f799a95a4f5ef502897f02c", "duckdb": "0f799a95a4f5ef502897f02c", "generic": "0f799a95a4f5ef502897f02c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0f799a95a4f5ef502897f02c", +"motherduck": "0f799a95a4f5ef502897f02c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0f799a95a4f5ef502897f02c", "postgresql": "0f799a95a4f5ef502897f02c", "snowflake": "0f799a95a4f5ef502897f02c", @@ -212,8 +212,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -229,8 +229,8 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "19bdd92ea0cc5fb028657510", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19bdd92ea0cc5fb028657510", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "19bdd92ea0cc5fb028657510", "postgresql": "19bdd92ea0cc5fb028657510", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -246,10 +246,10 @@ "databricks": "18db5afe2c1e80d1ee652b54", "duckdb": "18db5afe2c1e80d1ee652b54", "generic": "18db5afe2c1e80d1ee652b54", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "18db5afe2c1e80d1ee652b54", -"postgres": "18db5afe2c1e80d1ee652b54", -"postgresql": "18db5afe2c1e80d1ee652b54", +"motherduck": "18db5afe2c1e80d1ee652b54", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "47d64a5994d42a2b577166ea", +"postgresql": "47d64a5994d42a2b577166ea", "snowflake": "18db5afe2c1e80d1ee652b54", "tsql": "18db5afe2c1e80d1ee652b54" } @@ -259,14 +259,14 @@ { "DuckDB": "73151c1398b30e5c5d18f4ce", "None": "73151c1398b30e5c5d18f4ce", -"bigquery": "73151c1398b30e5c5d18f4ce", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "73151c1398b30e5c5d18f4ce", "duckdb": "73151c1398b30e5c5d18f4ce", "generic": "73151c1398b30e5c5d18f4ce", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73151c1398b30e5c5d18f4ce", -"postgres": "73151c1398b30e5c5d18f4ce", -"postgresql": "73151c1398b30e5c5d18f4ce", +"motherduck": "73151c1398b30e5c5d18f4ce", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f68b7dbd74ec7c3b9f3066ef", +"postgresql": "f68b7dbd74ec7c3b9f3066ef", "snowflake": "73151c1398b30e5c5d18f4ce", "tsql": "73151c1398b30e5c5d18f4ce" } @@ -275,17 +275,17 @@ "type", { "DuckDB": "3147a9e06daa6de4a4df5abc", -"None": "3147a9e06daa6de4a4df5abc", -"bigquery": "f276e907770196606577c932", -"databricks": "3147a9e06daa6de4a4df5abc", +"None": "da0625706f12b764a6912278", +"bigquery": "b0477b36767a62145aa9158c", +"databricks": "da0625706f12b764a6912278", "duckdb": "3147a9e06daa6de4a4df5abc", -"generic": "3147a9e06daa6de4a4df5abc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3147a9e06daa6de4a4df5abc", +"generic": "da0625706f12b764a6912278", +"motherduck": "3147a9e06daa6de4a4df5abc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3147a9e06daa6de4a4df5abc", "postgresql": "3147a9e06daa6de4a4df5abc", "snowflake": "67b5874a2c569226c490211f", -"tsql": "3147a9e06daa6de4a4df5abc" +"tsql": "da0625706f12b764a6912278" } ], [ @@ -297,8 +297,8 @@ "databricks": "0703bf71a54942bdaa28406e", "duckdb": "0703bf71a54942bdaa28406e", "generic": "0703bf71a54942bdaa28406e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0703bf71a54942bdaa28406e", +"motherduck": "0703bf71a54942bdaa28406e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0703bf71a54942bdaa28406e", "postgresql": "0703bf71a54942bdaa28406e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -314,8 +314,8 @@ "databricks": "78b2cf275c640af54feeca31", "duckdb": "78b2cf275c640af54feeca31", "generic": "78b2cf275c640af54feeca31", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "78b2cf275c640af54feeca31", +"motherduck": "78b2cf275c640af54feeca31", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "78b2cf275c640af54feeca31", "postgresql": "78b2cf275c640af54feeca31", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -331,8 +331,8 @@ "databricks": "f15c56475abfc73488abe63b", "duckdb": "f15c56475abfc73488abe63b", "generic": "f15c56475abfc73488abe63b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f15c56475abfc73488abe63b", +"motherduck": "f15c56475abfc73488abe63b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f15c56475abfc73488abe63b", "postgresql": "f15c56475abfc73488abe63b", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -348,8 +348,8 @@ "databricks": "717cf79ef777823eb3576deb", "duckdb": "717cf79ef777823eb3576deb", "generic": "717cf79ef777823eb3576deb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "717cf79ef777823eb3576deb", +"motherduck": "717cf79ef777823eb3576deb", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "717cf79ef777823eb3576deb", "postgresql": "717cf79ef777823eb3576deb", "snowflake": "717cf79ef777823eb3576deb", @@ -365,8 +365,8 @@ "databricks": "ea191a784359be345cd9ded6", "duckdb": "a6c6f4aa4257d422cbf3f875", "generic": "a6c6f4aa4257d422cbf3f875", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ea191a784359be345cd9ded6", +"motherduck": "a6c6f4aa4257d422cbf3f875", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a6c6f4aa4257d422cbf3f875", "postgresql": "a6c6f4aa4257d422cbf3f875", "snowflake": "a6c6f4aa4257d422cbf3f875", @@ -382,8 +382,8 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "78b2cf275c640af54feeca31", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19bdd92ea0cc5fb028657510", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "78b2cf275c640af54feeca31", "postgresql": "78b2cf275c640af54feeca31", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -395,12 +395,12 @@ { "DuckDB": "0f799a95a4f5ef502897f02c", "None": "0f799a95a4f5ef502897f02c", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "0f799a95a4f5ef502897f02c", "duckdb": "0f799a95a4f5ef502897f02c", "generic": "0f799a95a4f5ef502897f02c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0f799a95a4f5ef502897f02c", +"motherduck": "0f799a95a4f5ef502897f02c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0f799a95a4f5ef502897f02c", "postgresql": "0f799a95a4f5ef502897f02c", "snowflake": "0f799a95a4f5ef502897f02c", @@ -416,10 +416,10 @@ "databricks": "e9b32e3b5a5505b32f33e169", "duckdb": "e9b32e3b5a5505b32f33e169", "generic": "e9b32e3b5a5505b32f33e169", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e9b32e3b5a5505b32f33e169", -"postgres": "e9b32e3b5a5505b32f33e169", -"postgresql": "e9b32e3b5a5505b32f33e169", +"motherduck": "e9b32e3b5a5505b32f33e169", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3fd123ac5ae610dffb11b495", +"postgresql": "3fd123ac5ae610dffb11b495", "snowflake": "e9b32e3b5a5505b32f33e169", "tsql": "e9b32e3b5a5505b32f33e169" } @@ -433,8 +433,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -450,8 +450,8 @@ "databricks": "e4f0244beaa01667e80482b6", "duckdb": "a766fea06fc070b352976b0a", "generic": "a766fea06fc070b352976b0a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e4f0244beaa01667e80482b6", +"motherduck": "a766fea06fc070b352976b0a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a766fea06fc070b352976b0a", "postgresql": "a766fea06fc070b352976b0a", "snowflake": "a766fea06fc070b352976b0a", @@ -467,8 +467,8 @@ "databricks": "4fb572024031cb7631777be1", "duckdb": "4114b18e7e26d16613331fa7", "generic": "4114b18e7e26d16613331fa7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4114b18e7e26d16613331fa7", +"motherduck": "4114b18e7e26d16613331fa7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4114b18e7e26d16613331fa7", "postgresql": "4114b18e7e26d16613331fa7", "snowflake": "4114b18e7e26d16613331fa7", @@ -484,8 +484,8 @@ "databricks": "98a80237e4e0a12f35bbf17e", "duckdb": "98a80237e4e0a12f35bbf17e", "generic": "98a80237e4e0a12f35bbf17e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "98a80237e4e0a12f35bbf17e", +"motherduck": "98a80237e4e0a12f35bbf17e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "98a80237e4e0a12f35bbf17e", "postgresql": "98a80237e4e0a12f35bbf17e", "snowflake": "98a80237e4e0a12f35bbf17e", @@ -501,8 +501,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -518,8 +518,8 @@ "databricks": "f7fca17b74cc50ae3de8c826", "duckdb": "f7fca17b74cc50ae3de8c826", "generic": "f7fca17b74cc50ae3de8c826", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f7fca17b74cc50ae3de8c826", +"motherduck": "f7fca17b74cc50ae3de8c826", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f7fca17b74cc50ae3de8c826", "postgresql": "f7fca17b74cc50ae3de8c826", "snowflake": "55155766823b6a3a5e882fc2", @@ -535,8 +535,8 @@ "databricks": "9a79cb58680bebe49009a72d", "duckdb": "9a79cb58680bebe49009a72d", "generic": "9a79cb58680bebe49009a72d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9a79cb58680bebe49009a72d", +"motherduck": "9a79cb58680bebe49009a72d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9a79cb58680bebe49009a72d", "postgresql": "9a79cb58680bebe49009a72d", "snowflake": "9a79cb58680bebe49009a72d", @@ -552,8 +552,8 @@ "databricks": "9bafb08d41fd1c208b5deca4", "duckdb": "9bafb08d41fd1c208b5deca4", "generic": "9bafb08d41fd1c208b5deca4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9bafb08d41fd1c208b5deca4", +"motherduck": "9bafb08d41fd1c208b5deca4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9bafb08d41fd1c208b5deca4", "postgresql": "9bafb08d41fd1c208b5deca4", "snowflake": "9bafb08d41fd1c208b5deca4", @@ -565,14 +565,14 @@ { "DuckDB": "de89632e277dbc8c97115419", "None": "de89632e277dbc8c97115419", -"bigquery": "de89632e277dbc8c97115419", +"bigquery": "5abf4ec799a2ec32fb10da7e", "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -582,12 +582,12 @@ { "DuckDB": "2e60720c3255d112fcd0938a", "None": "2e60720c3255d112fcd0938a", -"bigquery": "2e60720c3255d112fcd0938a", +"bigquery": "d65a7c279b0fc9d3804ee30e", "databricks": "2e60720c3255d112fcd0938a", "duckdb": "2e60720c3255d112fcd0938a", "generic": "2e60720c3255d112fcd0938a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2e60720c3255d112fcd0938a", +"motherduck": "2e60720c3255d112fcd0938a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2e60720c3255d112fcd0938a", "postgresql": "2e60720c3255d112fcd0938a", "snowflake": "2e60720c3255d112fcd0938a", @@ -603,10 +603,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -615,17 +615,17 @@ "type", { "DuckDB": "c9cc0c1ce817773e19f141b5", -"None": "d7249dcf128bf2bb675aa0d9", -"bigquery": "d7249dcf128bf2bb675aa0d9", -"databricks": "f1640dc6a7437eae3cc39eec", +"None": "c70e0a464fcbb5e5a1f7a8b7", +"bigquery": "c70e0a464fcbb5e5a1f7a8b7", +"databricks": "c70e0a464fcbb5e5a1f7a8b7", "duckdb": "c9cc0c1ce817773e19f141b5", -"generic": "d7249dcf128bf2bb675aa0d9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d7249dcf128bf2bb675aa0d9", -"postgres": "d7249dcf128bf2bb675aa0d9", -"postgresql": "d7249dcf128bf2bb675aa0d9", +"generic": "c70e0a464fcbb5e5a1f7a8b7", +"motherduck": "c9cc0c1ce817773e19f141b5", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "c70e0a464fcbb5e5a1f7a8b7", +"postgresql": "c70e0a464fcbb5e5a1f7a8b7", "snowflake": "89091c4ddfa26794a7c15ab6", -"tsql": "d7249dcf128bf2bb675aa0d9" +"tsql": "c70e0a464fcbb5e5a1f7a8b7" } ], [ @@ -637,8 +637,8 @@ "databricks": "319a9fbb02ed503eb114164b", "duckdb": "e060b5a5a8e9774b580d58d3", "generic": "e060b5a5a8e9774b580d58d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "319a9fbb02ed503eb114164b", +"motherduck": "e060b5a5a8e9774b580d58d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e060b5a5a8e9774b580d58d3", "postgresql": "e060b5a5a8e9774b580d58d3", "snowflake": "e060b5a5a8e9774b580d58d3", @@ -654,8 +654,8 @@ "databricks": "3dbbe73ee4310c73030e8110", "duckdb": "3dbbe73ee4310c73030e8110", "generic": "3dbbe73ee4310c73030e8110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3dbbe73ee4310c73030e8110", +"motherduck": "3dbbe73ee4310c73030e8110", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3dbbe73ee4310c73030e8110", "postgresql": "3dbbe73ee4310c73030e8110", "snowflake": "f43dac38f34a1c0618a3f812", @@ -671,8 +671,8 @@ "databricks": "8111d803c9182d0189c728e9", "duckdb": "8111d803c9182d0189c728e9", "generic": "8111d803c9182d0189c728e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8111d803c9182d0189c728e9", +"motherduck": "8111d803c9182d0189c728e9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8111d803c9182d0189c728e9", "postgresql": "8111d803c9182d0189c728e9", "snowflake": "8111d803c9182d0189c728e9", @@ -688,8 +688,8 @@ "databricks": "f7fca17b74cc50ae3de8c826", "duckdb": "f7fca17b74cc50ae3de8c826", "generic": "f7fca17b74cc50ae3de8c826", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f7fca17b74cc50ae3de8c826", +"motherduck": "f7fca17b74cc50ae3de8c826", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f7fca17b74cc50ae3de8c826", "postgresql": "f7fca17b74cc50ae3de8c826", "snowflake": "55155766823b6a3a5e882fc2", @@ -705,8 +705,8 @@ "databricks": "d79c3ac70093cb4cb531e71c", "duckdb": "d79c3ac70093cb4cb531e71c", "generic": "d79c3ac70093cb4cb531e71c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d79c3ac70093cb4cb531e71c", +"motherduck": "d79c3ac70093cb4cb531e71c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d79c3ac70093cb4cb531e71c", "postgresql": "d79c3ac70093cb4cb531e71c", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -718,14 +718,14 @@ { "DuckDB": "4b356542044f1267fcfc487a", "None": "4b356542044f1267fcfc487a", -"bigquery": "4b356542044f1267fcfc487a", +"bigquery": "a5656d70e208254d1d3e9b4f", "databricks": "4b356542044f1267fcfc487a", "duckdb": "4b356542044f1267fcfc487a", "generic": "4b356542044f1267fcfc487a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4b356542044f1267fcfc487a", -"postgres": "4b356542044f1267fcfc487a", -"postgresql": "4b356542044f1267fcfc487a", +"motherduck": "4b356542044f1267fcfc487a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a5656d70e208254d1d3e9b4f", +"postgresql": "a5656d70e208254d1d3e9b4f", "snowflake": "4b356542044f1267fcfc487a", "tsql": "4b356542044f1267fcfc487a" } @@ -739,8 +739,8 @@ "databricks": "f0ec29663977eb66dca07a0e", "duckdb": "f0ec29663977eb66dca07a0e", "generic": "f0ec29663977eb66dca07a0e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f0ec29663977eb66dca07a0e", +"motherduck": "f0ec29663977eb66dca07a0e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f0ec29663977eb66dca07a0e", "postgresql": "f0ec29663977eb66dca07a0e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -752,14 +752,14 @@ { "DuckDB": "08736485547ba339930697e9", "None": "08736485547ba339930697e9", -"bigquery": "08736485547ba339930697e9", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "08736485547ba339930697e9", "duckdb": "08736485547ba339930697e9", "generic": "08736485547ba339930697e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "08736485547ba339930697e9", -"postgres": "08736485547ba339930697e9", -"postgresql": "08736485547ba339930697e9", +"motherduck": "08736485547ba339930697e9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eecd452b4f5f3f4133d0bd0a", +"postgresql": "eecd452b4f5f3f4133d0bd0a", "snowflake": "08736485547ba339930697e9", "tsql": "08736485547ba339930697e9" } @@ -773,8 +773,8 @@ "databricks": "8a3f094f18fb4047f0febf59", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "8a3f094f18fb4047f0febf59", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8a3f094f18fb4047f0febf59", "postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "850deea990b52b82b36a9848", @@ -790,10 +790,10 @@ "databricks": "64fc778308b798a730b1d5c9", "duckdb": "64fc778308b798a730b1d5c9", "generic": "64fc778308b798a730b1d5c9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "64fc778308b798a730b1d5c9", -"postgres": "64fc778308b798a730b1d5c9", -"postgresql": "64fc778308b798a730b1d5c9", +"motherduck": "64fc778308b798a730b1d5c9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "c8ca7a940ad228dd836cad6f", +"postgresql": "c8ca7a940ad228dd836cad6f", "snowflake": "64fc778308b798a730b1d5c9", "tsql": "64fc778308b798a730b1d5c9" } @@ -807,8 +807,8 @@ "databricks": "b46dfa976d5ba04f95bea32b", "duckdb": "b46dfa976d5ba04f95bea32b", "generic": "b46dfa976d5ba04f95bea32b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b46dfa976d5ba04f95bea32b", +"motherduck": "b46dfa976d5ba04f95bea32b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "34dcdfe3e3afe6140e1353e0", "postgresql": "34dcdfe3e3afe6140e1353e0", "snowflake": "b46dfa976d5ba04f95bea32b", @@ -824,8 +824,8 @@ "databricks": "20c9f38cf0da7cc6079a3a47", "duckdb": "20c9f38cf0da7cc6079a3a47", "generic": "20c9f38cf0da7cc6079a3a47", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "20c9f38cf0da7cc6079a3a47", +"motherduck": "20c9f38cf0da7cc6079a3a47", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "20c9f38cf0da7cc6079a3a47", "postgresql": "20c9f38cf0da7cc6079a3a47", "snowflake": "20c9f38cf0da7cc6079a3a47", @@ -841,8 +841,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -858,8 +858,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -871,14 +871,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -892,8 +892,8 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "19a1a80ffc06169f32694de8", "postgresql": "19a1a80ffc06169f32694de8", "snowflake": "19a1a80ffc06169f32694de8", @@ -909,8 +909,8 @@ "databricks": "6ef74921b43664a98de3f7e4", "duckdb": "09a5861e271d932cd3a9a264", "generic": "6ef74921b43664a98de3f7e4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "09a5861e271d932cd3a9a264", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cc685e113aac64bd76fbc3cb", "postgresql": "cc685e113aac64bd76fbc3cb", "snowflake": "6fe4c4c52324360189048430", @@ -926,8 +926,8 @@ "databricks": "46ec3e19e05a6cb29854ccac", "duckdb": "35e216b6921bf843994f2eea", "generic": "46ec3e19e05a6cb29854ccac", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "46ec3e19e05a6cb29854ccac", +"motherduck": "35e216b6921bf843994f2eea", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "46ec3e19e05a6cb29854ccac", "postgresql": "46ec3e19e05a6cb29854ccac", "snowflake": "46ec3e19e05a6cb29854ccac", @@ -943,10 +943,10 @@ "databricks": "de89632e277dbc8c97115419", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -960,8 +960,8 @@ "databricks": "1950e32420d1d40d41ffae64", "duckdb": "1950e32420d1d40d41ffae64", "generic": "1950e32420d1d40d41ffae64", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1950e32420d1d40d41ffae64", +"motherduck": "1950e32420d1d40d41ffae64", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1950e32420d1d40d41ffae64", "postgresql": "1950e32420d1d40d41ffae64", "snowflake": "1950e32420d1d40d41ffae64", @@ -977,8 +977,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -994,8 +994,8 @@ "databricks": "9e4a50a8aab648a9737f7d0c", "duckdb": "9e4a50a8aab648a9737f7d0c", "generic": "9e4a50a8aab648a9737f7d0c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9e4a50a8aab648a9737f7d0c", +"motherduck": "9e4a50a8aab648a9737f7d0c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "36d29258901a4d8c296baa68", "postgresql": "36d29258901a4d8c296baa68", "snowflake": "9e4a50a8aab648a9737f7d0c", @@ -1007,12 +1007,12 @@ { "DuckDB": "461923a0d34defd0c726d6e5", "None": "461923a0d34defd0c726d6e5", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "461923a0d34defd0c726d6e5", "duckdb": "461923a0d34defd0c726d6e5", "generic": "461923a0d34defd0c726d6e5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "461923a0d34defd0c726d6e5", +"motherduck": "461923a0d34defd0c726d6e5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "461923a0d34defd0c726d6e5", "postgresql": "461923a0d34defd0c726d6e5", "snowflake": "461923a0d34defd0c726d6e5", @@ -1028,8 +1028,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -1045,8 +1045,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "8441d00030df06ad6a5534d3", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "8441d00030df06ad6a5534d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -1058,14 +1058,14 @@ { "DuckDB": "e46d4be44ab9e500e9190d26", "None": "e46d4be44ab9e500e9190d26", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -1079,8 +1079,8 @@ "databricks": "a7120d1b1abcb844c87a968a", "duckdb": "a7120d1b1abcb844c87a968a", "generic": "a7120d1b1abcb844c87a968a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a7120d1b1abcb844c87a968a", +"motherduck": "a7120d1b1abcb844c87a968a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a7120d1b1abcb844c87a968a", "postgresql": "a7120d1b1abcb844c87a968a", "snowflake": "a7120d1b1abcb844c87a968a", @@ -1096,8 +1096,8 @@ "databricks": "cc2a8dbf7a9806988a7b5067", "duckdb": "cc2a8dbf7a9806988a7b5067", "generic": "cc2a8dbf7a9806988a7b5067", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cc2a8dbf7a9806988a7b5067", +"motherduck": "cc2a8dbf7a9806988a7b5067", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cc2a8dbf7a9806988a7b5067", "postgresql": "cc2a8dbf7a9806988a7b5067", "snowflake": "cc2a8dbf7a9806988a7b5067", @@ -1113,8 +1113,8 @@ "databricks": "5d4d5145235f17764810d03f", "duckdb": "5d4d5145235f17764810d03f", "generic": "5d4d5145235f17764810d03f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d4d5145235f17764810d03f", +"motherduck": "5d4d5145235f17764810d03f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5d4d5145235f17764810d03f", "postgresql": "5d4d5145235f17764810d03f", "snowflake": "5d4d5145235f17764810d03f", @@ -1130,8 +1130,8 @@ "databricks": "2427f5522575cdc3d6a74e4c", "duckdb": "2427f5522575cdc3d6a74e4c", "generic": "2427f5522575cdc3d6a74e4c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2427f5522575cdc3d6a74e4c", +"motherduck": "2427f5522575cdc3d6a74e4c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2427f5522575cdc3d6a74e4c", "postgresql": "2427f5522575cdc3d6a74e4c", "snowflake": "2427f5522575cdc3d6a74e4c", @@ -1147,8 +1147,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -1164,8 +1164,8 @@ "databricks": "12b8a08a67c6c5ca887183e3", "duckdb": "97d3bfe2b726a642c0011696", "generic": "5a48ec343f2513c62588cb55", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5a48ec343f2513c62588cb55", +"motherduck": "97d3bfe2b726a642c0011696", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5a48ec343f2513c62588cb55", "postgresql": "5a48ec343f2513c62588cb55", "snowflake": "582c76388cd6468a1e793692", @@ -1181,8 +1181,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "8441d00030df06ad6a5534d3", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "8441d00030df06ad6a5534d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -1198,11 +1198,11 @@ "databricks": "b5c4d5044b2a6e70633f0d0a", "duckdb": "b5c4d5044b2a6e70633f0d0a", "generic": "b5c4d5044b2a6e70633f0d0a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b5c4d5044b2a6e70633f0d0a", +"motherduck": "b5c4d5044b2a6e70633f0d0a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b5c4d5044b2a6e70633f0d0a", "postgresql": "b5c4d5044b2a6e70633f0d0a", -"snowflake": "4e24a80b20b9dee0cbbfac17", +"snowflake": "8ff614b7306c0edbe36ce00b", "tsql": "b5c4d5044b2a6e70633f0d0a" } ], @@ -1215,8 +1215,8 @@ "databricks": "ac984ee30077ed3bb3c7c9d5", "duckdb": "7a8df655ee308ea4f929b9fd", "generic": "7a8df655ee308ea4f929b9fd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ac984ee30077ed3bb3c7c9d5", +"motherduck": "7a8df655ee308ea4f929b9fd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7a8df655ee308ea4f929b9fd", "postgresql": "7a8df655ee308ea4f929b9fd", "snowflake": "7a8df655ee308ea4f929b9fd", @@ -1232,10 +1232,10 @@ "databricks": "804fec6876d0b43935790142", "duckdb": "804fec6876d0b43935790142", "generic": "804fec6876d0b43935790142", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "804fec6876d0b43935790142", -"postgres": "804fec6876d0b43935790142", -"postgresql": "804fec6876d0b43935790142", +"motherduck": "804fec6876d0b43935790142", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "191fc59c754706512337edc1", +"postgresql": "191fc59c754706512337edc1", "snowflake": "804fec6876d0b43935790142", "tsql": "804fec6876d0b43935790142" } @@ -1249,8 +1249,8 @@ "databricks": "8a4c61c12f9eaa564d1c19a1", "duckdb": "8a4c61c12f9eaa564d1c19a1", "generic": "8a4c61c12f9eaa564d1c19a1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8a4c61c12f9eaa564d1c19a1", +"motherduck": "8a4c61c12f9eaa564d1c19a1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8a4c61c12f9eaa564d1c19a1", "postgresql": "8a4c61c12f9eaa564d1c19a1", "snowflake": "8a4c61c12f9eaa564d1c19a1", @@ -1266,8 +1266,8 @@ "databricks": "fcb2bd160300a30539bd5398", "duckdb": "fcb2bd160300a30539bd5398", "generic": "fcb2bd160300a30539bd5398", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fcb2bd160300a30539bd5398", +"motherduck": "fcb2bd160300a30539bd5398", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fcb2bd160300a30539bd5398", "postgresql": "fcb2bd160300a30539bd5398", "snowflake": "fcb2bd160300a30539bd5398", @@ -1279,14 +1279,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -1300,8 +1300,8 @@ "databricks": "d3bcf10e00645b12a802c7d0", "duckdb": "c0eec31620dfc2ac0028173d", "generic": "d3bcf10e00645b12a802c7d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "c0eec31620dfc2ac0028173d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c0eec31620dfc2ac0028173d", "postgresql": "c0eec31620dfc2ac0028173d", "snowflake": "d379c0ee4dad89e570b7329e", @@ -1313,12 +1313,12 @@ { "DuckDB": "06aec7cca4b30489405665e2", "None": "06aec7cca4b30489405665e2", -"bigquery": "06aec7cca4b30489405665e2", +"bigquery": "96fb49e9038c050a39793710", "databricks": "06aec7cca4b30489405665e2", "duckdb": "06aec7cca4b30489405665e2", "generic": "06aec7cca4b30489405665e2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "06aec7cca4b30489405665e2", +"motherduck": "06aec7cca4b30489405665e2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "06aec7cca4b30489405665e2", "postgresql": "06aec7cca4b30489405665e2", "snowflake": "06aec7cca4b30489405665e2", @@ -1334,8 +1334,8 @@ "databricks": "76b7de42fb46036e5c9279bf", "duckdb": "76b7de42fb46036e5c9279bf", "generic": "76b7de42fb46036e5c9279bf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "76b7de42fb46036e5c9279bf", +"motherduck": "76b7de42fb46036e5c9279bf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "76b7de42fb46036e5c9279bf", "postgresql": "76b7de42fb46036e5c9279bf", "snowflake": "76b7de42fb46036e5c9279bf", @@ -1351,8 +1351,8 @@ "databricks": "93c1b5b5960e26479baf88d0", "duckdb": "93c1b5b5960e26479baf88d0", "generic": "93c1b5b5960e26479baf88d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "93c1b5b5960e26479baf88d0", +"motherduck": "93c1b5b5960e26479baf88d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "93c1b5b5960e26479baf88d0", "postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "93c1b5b5960e26479baf88d0", @@ -1368,8 +1368,8 @@ "databricks": "9db9d9c0f19fb71af06e1044", "duckdb": "3b3de43279bf3f0706595e4a", "generic": "9db9d9c0f19fb71af06e1044", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "3b3de43279bf3f0706595e4a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3b3de43279bf3f0706595e4a", "postgresql": "3b3de43279bf3f0706595e4a", "snowflake": "0b6d401f07331fac8353bbd3", @@ -1385,8 +1385,8 @@ "databricks": "6965b3d5426a0af9750f9a03", "duckdb": "6965b3d5426a0af9750f9a03", "generic": "6965b3d5426a0af9750f9a03", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6965b3d5426a0af9750f9a03", +"motherduck": "6965b3d5426a0af9750f9a03", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6965b3d5426a0af9750f9a03", "postgresql": "6965b3d5426a0af9750f9a03", "snowflake": "6965b3d5426a0af9750f9a03", @@ -1402,8 +1402,8 @@ "databricks": "7aa59eed1bba74a9dee48e59", "duckdb": "7aa59eed1bba74a9dee48e59", "generic": "7aa59eed1bba74a9dee48e59", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7aa59eed1bba74a9dee48e59", +"motherduck": "7aa59eed1bba74a9dee48e59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7aa59eed1bba74a9dee48e59", "postgresql": "7aa59eed1bba74a9dee48e59", "snowflake": "7aa59eed1bba74a9dee48e59", @@ -1419,8 +1419,8 @@ "databricks": "66e7166890ccedeaad6c241a", "duckdb": "66e7166890ccedeaad6c241a", "generic": "66e7166890ccedeaad6c241a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "66e7166890ccedeaad6c241a", +"motherduck": "66e7166890ccedeaad6c241a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "66e7166890ccedeaad6c241a", "postgresql": "66e7166890ccedeaad6c241a", "snowflake": "66e7166890ccedeaad6c241a", @@ -1436,8 +1436,8 @@ "databricks": "9aff7fcc7d550e1a8d105471", "duckdb": "9aff7fcc7d550e1a8d105471", "generic": "9aff7fcc7d550e1a8d105471", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9aff7fcc7d550e1a8d105471", +"motherduck": "9aff7fcc7d550e1a8d105471", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9aff7fcc7d550e1a8d105471", "postgresql": "9aff7fcc7d550e1a8d105471", "snowflake": "9aff7fcc7d550e1a8d105471", @@ -1449,12 +1449,12 @@ { "DuckDB": "b561884132dbe7e42b719110", "None": "b561884132dbe7e42b719110", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "b561884132dbe7e42b719110", "duckdb": "b561884132dbe7e42b719110", "generic": "b561884132dbe7e42b719110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b561884132dbe7e42b719110", +"motherduck": "b561884132dbe7e42b719110", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b561884132dbe7e42b719110", "postgresql": "b561884132dbe7e42b719110", "snowflake": "b561884132dbe7e42b719110", @@ -1470,10 +1470,10 @@ "databricks": "fb6eefdc9bed918e3ac82197", "duckdb": "fb6eefdc9bed918e3ac82197", "generic": "fb6eefdc9bed918e3ac82197", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fb6eefdc9bed918e3ac82197", -"postgres": "fb6eefdc9bed918e3ac82197", -"postgresql": "fb6eefdc9bed918e3ac82197", +"motherduck": "fb6eefdc9bed918e3ac82197", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "4d3368f4985b5822bc4239af", +"postgresql": "4d3368f4985b5822bc4239af", "snowflake": "fb6eefdc9bed918e3ac82197", "tsql": "fb6eefdc9bed918e3ac82197" } @@ -1481,16 +1481,16 @@ [ "type", { -"DuckDB": "8698d724534891869075175e", -"None": "0017a88bb60ec3403c786ed8", +"DuckDB": "aa7afbd57560be67e5221a3b", +"None": "47e0816fecdd9e015d7aeb79", "bigquery": "47e0816fecdd9e015d7aeb79", -"databricks": "0017a88bb60ec3403c786ed8", -"duckdb": "8698d724534891869075175e", -"generic": "0017a88bb60ec3403c786ed8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "8698d724534891869075175e", -"postgresql": "8698d724534891869075175e", +"databricks": "47e0816fecdd9e015d7aeb79", +"duckdb": "aa7afbd57560be67e5221a3b", +"generic": "47e0816fecdd9e015d7aeb79", +"motherduck": "aa7afbd57560be67e5221a3b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "aa7afbd57560be67e5221a3b", +"postgresql": "aa7afbd57560be67e5221a3b", "snowflake": "e6f36041b1d9fb8fe3a18cbb", "tsql": "d1dc9a140dbe2eb1874c6ad7" } @@ -1504,8 +1504,8 @@ "databricks": "0a22fc4bfa30bc1953d41de6", "duckdb": "ee07062f9d57cfdfb20f327b", "generic": "ee07062f9d57cfdfb20f327b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ee07062f9d57cfdfb20f327b", +"motherduck": "ee07062f9d57cfdfb20f327b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0a9a262e0d175ab0eb0865e2", "postgresql": "0a9a262e0d175ab0eb0865e2", "snowflake": "0f4d95882eb1debabb5a887b", @@ -1521,8 +1521,8 @@ "databricks": "0c43dc837a50933667588ef1", "duckdb": "0c43dc837a50933667588ef1", "generic": "0c43dc837a50933667588ef1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0c43dc837a50933667588ef1", +"motherduck": "0c43dc837a50933667588ef1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0c43dc837a50933667588ef1", "postgresql": "0c43dc837a50933667588ef1", "snowflake": "0c43dc837a50933667588ef1", @@ -1534,14 +1534,14 @@ { "DuckDB": "d2c97d221599d038d9875873", "None": "d2c97d221599d038d9875873", -"bigquery": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", "databricks": "d2c97d221599d038d9875873", "duckdb": "d2c97d221599d038d9875873", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "d2c97d221599d038d9875873", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -1555,10 +1555,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -1572,8 +1572,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -1585,14 +1585,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -1606,8 +1606,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -1623,8 +1623,8 @@ "databricks": "0c4610f182f18bf41d306e01", "duckdb": "0c4610f182f18bf41d306e01", "generic": "0c4610f182f18bf41d306e01", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0c4610f182f18bf41d306e01", +"motherduck": "0c4610f182f18bf41d306e01", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0c4610f182f18bf41d306e01", "postgresql": "0c4610f182f18bf41d306e01", "snowflake": "0c4610f182f18bf41d306e01", @@ -1640,8 +1640,8 @@ "databricks": "ab5ad6180652b3b00d1f5b01", "duckdb": "ab5ad6180652b3b00d1f5b01", "generic": "ab5ad6180652b3b00d1f5b01", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ab5ad6180652b3b00d1f5b01", +"motherduck": "ab5ad6180652b3b00d1f5b01", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ab5ad6180652b3b00d1f5b01", "postgresql": "ab5ad6180652b3b00d1f5b01", "snowflake": "f43dac38f34a1c0618a3f812", @@ -1657,8 +1657,8 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "1d8b945fd793ecdcacb90c21", "generic": "1d8b945fd793ecdcacb90c21", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1d8b945fd793ecdcacb90c21", +"motherduck": "1d8b945fd793ecdcacb90c21", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3efe8bb57c98fcbe74096b3c", "postgresql": "3efe8bb57c98fcbe74096b3c", "snowflake": "1d8b945fd793ecdcacb90c21", @@ -1670,14 +1670,14 @@ { "DuckDB": "5d25d5e13f81700741695ed4", "None": "5d25d5e13f81700741695ed4", -"bigquery": "23ee196b7bd6039855a1460f", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "5d25d5e13f81700741695ed4", "duckdb": "5d25d5e13f81700741695ed4", "generic": "5d25d5e13f81700741695ed4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d25d5e13f81700741695ed4", -"postgres": "5d25d5e13f81700741695ed4", -"postgresql": "5d25d5e13f81700741695ed4", +"motherduck": "5d25d5e13f81700741695ed4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "62131fb5b065f5de2e74a0f1", +"postgresql": "62131fb5b065f5de2e74a0f1", "snowflake": "5d25d5e13f81700741695ed4", "tsql": "5d25d5e13f81700741695ed4" } @@ -1691,8 +1691,8 @@ "databricks": "adbb06204fd66d8071c3dbc6", "duckdb": "29739921db4d47abc1ac18c7", "generic": "29739921db4d47abc1ac18c7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "29739921db4d47abc1ac18c7", +"motherduck": "29739921db4d47abc1ac18c7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "29739921db4d47abc1ac18c7", "postgresql": "29739921db4d47abc1ac18c7", "snowflake": "216a7f0ead009a087eea4e1c", @@ -1708,10 +1708,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -1721,14 +1721,14 @@ { "DuckDB": "ee47e1424cb01deb0cf51760", "None": "ee47e1424cb01deb0cf51760", -"bigquery": "ee47e1424cb01deb0cf51760", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "ee47e1424cb01deb0cf51760", "duckdb": "ee47e1424cb01deb0cf51760", "generic": "ee47e1424cb01deb0cf51760", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ee47e1424cb01deb0cf51760", -"postgres": "ee47e1424cb01deb0cf51760", -"postgresql": "ee47e1424cb01deb0cf51760", +"motherduck": "ee47e1424cb01deb0cf51760", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3c1521654088dd54d0dc9ead", +"postgresql": "3c1521654088dd54d0dc9ead", "snowflake": "ee47e1424cb01deb0cf51760", "tsql": "ee47e1424cb01deb0cf51760" } @@ -1742,8 +1742,8 @@ "databricks": "b4c316e81db1cb6a277b5d27", "duckdb": "1655128a72b1db9af6a89df3", "generic": "1655128a72b1db9af6a89df3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b4c316e81db1cb6a277b5d27", +"motherduck": "1655128a72b1db9af6a89df3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1655128a72b1db9af6a89df3", "postgresql": "1655128a72b1db9af6a89df3", "snowflake": "1655128a72b1db9af6a89df3", @@ -1754,17 +1754,17 @@ "type", { "DuckDB": "f2ed52f6bf46b4db9343551c", -"None": "f2ed52f6bf46b4db9343551c", -"bigquery": "f10bdd4d40eb495cbcecd31d", -"databricks": "f2ed52f6bf46b4db9343551c", +"None": "3f998a9ab68d8b2514840489", +"bigquery": "1e75e5227bea0ae294ac7af1", +"databricks": "3f998a9ab68d8b2514840489", "duckdb": "f2ed52f6bf46b4db9343551c", -"generic": "f2ed52f6bf46b4db9343551c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f2ed52f6bf46b4db9343551c", -"postgres": "f2ed52f6bf46b4db9343551c", -"postgresql": "f2ed52f6bf46b4db9343551c", +"generic": "3f998a9ab68d8b2514840489", +"motherduck": "f2ed52f6bf46b4db9343551c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "7ce41cc5375b618de22b6a4e", +"postgresql": "7ce41cc5375b618de22b6a4e", "snowflake": "f2ed52f6bf46b4db9343551c", -"tsql": "f2ed52f6bf46b4db9343551c" +"tsql": "3f998a9ab68d8b2514840489" } ], [ @@ -1776,8 +1776,8 @@ "databricks": "b46dfa976d5ba04f95bea32b", "duckdb": "b46dfa976d5ba04f95bea32b", "generic": "b46dfa976d5ba04f95bea32b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b46dfa976d5ba04f95bea32b", +"motherduck": "b46dfa976d5ba04f95bea32b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "34dcdfe3e3afe6140e1353e0", "postgresql": "34dcdfe3e3afe6140e1353e0", "snowflake": "b46dfa976d5ba04f95bea32b", @@ -1793,8 +1793,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -1810,10 +1810,10 @@ "databricks": "3e611643f0beab4953c4e09b", "duckdb": "3e611643f0beab4953c4e09b", "generic": "3e611643f0beab4953c4e09b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3e611643f0beab4953c4e09b", -"postgres": "3e611643f0beab4953c4e09b", -"postgresql": "3e611643f0beab4953c4e09b", +"motherduck": "3e611643f0beab4953c4e09b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "cae477ce59c72869f37a9a40", +"postgresql": "cae477ce59c72869f37a9a40", "snowflake": "3e611643f0beab4953c4e09b", "tsql": "3e611643f0beab4953c4e09b" } @@ -1827,10 +1827,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -1840,12 +1840,12 @@ { "DuckDB": "62368fc15cefd5807807b209", "None": "62368fc15cefd5807807b209", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "62368fc15cefd5807807b209", "duckdb": "62368fc15cefd5807807b209", "generic": "62368fc15cefd5807807b209", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "62368fc15cefd5807807b209", +"motherduck": "62368fc15cefd5807807b209", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "62368fc15cefd5807807b209", "postgresql": "62368fc15cefd5807807b209", "snowflake": "62368fc15cefd5807807b209", @@ -1861,8 +1861,8 @@ "databricks": "17a6d1702d6997aa4e447f46", "duckdb": "755657fbcced1de4551fb370", "generic": "17a6d1702d6997aa4e447f46", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "17a6d1702d6997aa4e447f46", +"motherduck": "755657fbcced1de4551fb370", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "17a6d1702d6997aa4e447f46", "postgresql": "17a6d1702d6997aa4e447f46", "snowflake": "17a6d1702d6997aa4e447f46", @@ -1878,8 +1878,8 @@ "databricks": "8d66732c326e570c1efcd995", "duckdb": "8d66732c326e570c1efcd995", "generic": "8d66732c326e570c1efcd995", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8d66732c326e570c1efcd995", +"motherduck": "8d66732c326e570c1efcd995", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8d66732c326e570c1efcd995", "postgresql": "8d66732c326e570c1efcd995", "snowflake": "8d66732c326e570c1efcd995", @@ -1895,8 +1895,8 @@ "databricks": "caf173733defe796376d4efe", "duckdb": "caf173733defe796376d4efe", "generic": "caf173733defe796376d4efe", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "caf173733defe796376d4efe", +"motherduck": "caf173733defe796376d4efe", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "caf173733defe796376d4efe", "postgresql": "caf173733defe796376d4efe", "snowflake": "caf173733defe796376d4efe", @@ -1908,14 +1908,14 @@ { "DuckDB": "de89632e277dbc8c97115419", "None": "de89632e277dbc8c97115419", -"bigquery": "de89632e277dbc8c97115419", +"bigquery": "5abf4ec799a2ec32fb10da7e", "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -1926,11 +1926,11 @@ "DuckDB": "14cd6e78d75f61b2bd1bbd71", "None": "14cd6e78d75f61b2bd1bbd71", "bigquery": "14cd6e78d75f61b2bd1bbd71", -"databricks": "73504f31156e8e661c1fb26c", +"databricks": "14cd6e78d75f61b2bd1bbd71", "duckdb": "14cd6e78d75f61b2bd1bbd71", "generic": "14cd6e78d75f61b2bd1bbd71", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73504f31156e8e661c1fb26c", +"motherduck": "14cd6e78d75f61b2bd1bbd71", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "14cd6e78d75f61b2bd1bbd71", "postgresql": "14cd6e78d75f61b2bd1bbd71", "snowflake": "14cd6e78d75f61b2bd1bbd71", @@ -1946,8 +1946,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -1963,8 +1963,8 @@ "databricks": "cf5e019d9de8b46b75fdfdb6", "duckdb": "cf5e019d9de8b46b75fdfdb6", "generic": "cf5e019d9de8b46b75fdfdb6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cf5e019d9de8b46b75fdfdb6", +"motherduck": "cf5e019d9de8b46b75fdfdb6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cf5e019d9de8b46b75fdfdb6", "postgresql": "cf5e019d9de8b46b75fdfdb6", "snowflake": "cf5e019d9de8b46b75fdfdb6", @@ -1976,12 +1976,12 @@ { "DuckDB": "4f8af4650ce9c18ed0cb0bca", "None": "4f8af4650ce9c18ed0cb0bca", -"bigquery": "4f8af4650ce9c18ed0cb0bca", +"bigquery": "307965c44698c3db5bfa1db9", "databricks": "4f8af4650ce9c18ed0cb0bca", "duckdb": "4f8af4650ce9c18ed0cb0bca", "generic": "4f8af4650ce9c18ed0cb0bca", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4f8af4650ce9c18ed0cb0bca", +"motherduck": "4f8af4650ce9c18ed0cb0bca", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4f8af4650ce9c18ed0cb0bca", "postgresql": "4f8af4650ce9c18ed0cb0bca", "snowflake": "4f8af4650ce9c18ed0cb0bca", @@ -1993,12 +1993,12 @@ { "DuckDB": "cbd04e906c540e91d7c8ea88", "None": "cbd04e906c540e91d7c8ea88", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "cbd04e906c540e91d7c8ea88", "duckdb": "cbd04e906c540e91d7c8ea88", "generic": "cbd04e906c540e91d7c8ea88", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cbd04e906c540e91d7c8ea88", +"motherduck": "cbd04e906c540e91d7c8ea88", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cbd04e906c540e91d7c8ea88", "postgresql": "cbd04e906c540e91d7c8ea88", "snowflake": "cbd04e906c540e91d7c8ea88", @@ -2009,17 +2009,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -2031,10 +2031,10 @@ "databricks": "8b8d5f75ba6dec68b4cebc6b", "duckdb": "8b8d5f75ba6dec68b4cebc6b", "generic": "8b8d5f75ba6dec68b4cebc6b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8b8d5f75ba6dec68b4cebc6b", -"postgres": "8b8d5f75ba6dec68b4cebc6b", -"postgresql": "8b8d5f75ba6dec68b4cebc6b", +"motherduck": "8b8d5f75ba6dec68b4cebc6b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "7914189ff18b0e70ddf7d042", +"postgresql": "7914189ff18b0e70ddf7d042", "snowflake": "8b8d5f75ba6dec68b4cebc6b", "tsql": "8b8d5f75ba6dec68b4cebc6b" } @@ -2044,12 +2044,12 @@ { "DuckDB": "aae2b1fe6f2d9807ecde412b", "None": "aae2b1fe6f2d9807ecde412b", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "aae2b1fe6f2d9807ecde412b", "duckdb": "aae2b1fe6f2d9807ecde412b", "generic": "aae2b1fe6f2d9807ecde412b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aae2b1fe6f2d9807ecde412b", +"motherduck": "aae2b1fe6f2d9807ecde412b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "aae2b1fe6f2d9807ecde412b", "postgresql": "aae2b1fe6f2d9807ecde412b", "snowflake": "aae2b1fe6f2d9807ecde412b", @@ -2065,10 +2065,10 @@ "databricks": "38b2ec94bf02be40007ce525", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -2082,8 +2082,8 @@ "databricks": "036dd6864cf4939023240245", "duckdb": "f30e987a1e4e17305f6863ad", "generic": "036dd6864cf4939023240245", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "f30e987a1e4e17305f6863ad", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f30e987a1e4e17305f6863ad", "postgresql": "f30e987a1e4e17305f6863ad", "snowflake": "ff9e7821f3892ba4ddf70a84", @@ -2099,10 +2099,10 @@ "databricks": "bce60580ef3a1dc4ce569fff", "duckdb": "bce60580ef3a1dc4ce569fff", "generic": "bce60580ef3a1dc4ce569fff", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "bce60580ef3a1dc4ce569fff", -"postgres": "bce60580ef3a1dc4ce569fff", -"postgresql": "bce60580ef3a1dc4ce569fff", +"motherduck": "bce60580ef3a1dc4ce569fff", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eee236ea1427bdddbaf088ac", +"postgresql": "eee236ea1427bdddbaf088ac", "snowflake": "bce60580ef3a1dc4ce569fff", "tsql": "bce60580ef3a1dc4ce569fff" } @@ -2116,10 +2116,10 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "19e127c23b4598727a2d8ceb", "generic": "19e127c23b4598727a2d8ceb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aed0419e7f2ce7c0a8892248", -"postgres": "19e127c23b4598727a2d8ceb", -"postgresql": "19e127c23b4598727a2d8ceb", +"motherduck": "19e127c23b4598727a2d8ceb", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "111af35848fe500ec2ae54b2", +"postgresql": "111af35848fe500ec2ae54b2", "snowflake": "aed0419e7f2ce7c0a8892248", "tsql": "19e127c23b4598727a2d8ceb" } @@ -2133,8 +2133,8 @@ "databricks": "558da38ec4d9d5d6c72f60cf", "duckdb": "558da38ec4d9d5d6c72f60cf", "generic": "558da38ec4d9d5d6c72f60cf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "558da38ec4d9d5d6c72f60cf", +"motherduck": "558da38ec4d9d5d6c72f60cf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "558da38ec4d9d5d6c72f60cf", "postgresql": "558da38ec4d9d5d6c72f60cf", "snowflake": "558da38ec4d9d5d6c72f60cf", @@ -2150,8 +2150,8 @@ "databricks": "f43dac38f34a1c0618a3f812", "duckdb": "f43dac38f34a1c0618a3f812", "generic": "f43dac38f34a1c0618a3f812", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f43dac38f34a1c0618a3f812", +"motherduck": "f43dac38f34a1c0618a3f812", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f43dac38f34a1c0618a3f812", "postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "f43dac38f34a1c0618a3f812", @@ -2167,8 +2167,8 @@ "databricks": "3dbbe73ee4310c73030e8110", "duckdb": "3dbbe73ee4310c73030e8110", "generic": "3dbbe73ee4310c73030e8110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3dbbe73ee4310c73030e8110", +"motherduck": "3dbbe73ee4310c73030e8110", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3dbbe73ee4310c73030e8110", "postgresql": "3dbbe73ee4310c73030e8110", "snowflake": "f43dac38f34a1c0618a3f812", @@ -2184,10 +2184,10 @@ "databricks": "c6106f30f23f392e17eadef4", "duckdb": "c6106f30f23f392e17eadef4", "generic": "c6106f30f23f392e17eadef4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6106f30f23f392e17eadef4", -"postgres": "c6106f30f23f392e17eadef4", -"postgresql": "c6106f30f23f392e17eadef4", +"motherduck": "c6106f30f23f392e17eadef4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f43dac38f34a1c0618a3f812", +"postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "c6106f30f23f392e17eadef4", "tsql": "c6106f30f23f392e17eadef4" } @@ -2201,8 +2201,8 @@ "databricks": "cfb4a49a57197b0df1b2e905", "duckdb": "cfb4a49a57197b0df1b2e905", "generic": "cfb4a49a57197b0df1b2e905", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cfb4a49a57197b0df1b2e905", +"motherduck": "cfb4a49a57197b0df1b2e905", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cfb4a49a57197b0df1b2e905", "postgresql": "cfb4a49a57197b0df1b2e905", "snowflake": "cfb4a49a57197b0df1b2e905", @@ -2218,8 +2218,8 @@ "databricks": "8790273499dae4e6cbd2d034", "duckdb": "8790273499dae4e6cbd2d034", "generic": "8790273499dae4e6cbd2d034", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8790273499dae4e6cbd2d034", +"motherduck": "8790273499dae4e6cbd2d034", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8790273499dae4e6cbd2d034", "postgresql": "8790273499dae4e6cbd2d034", "snowflake": "9aff7fcc7d550e1a8d105471", @@ -2235,8 +2235,8 @@ "databricks": "e8605878c6fffc044556a858", "duckdb": "e8605878c6fffc044556a858", "generic": "e8605878c6fffc044556a858", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e8605878c6fffc044556a858", +"motherduck": "e8605878c6fffc044556a858", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8605878c6fffc044556a858", "postgresql": "e8605878c6fffc044556a858", "snowflake": "e8605878c6fffc044556a858", @@ -2252,8 +2252,8 @@ "databricks": "355fafbc65133795e6c5e43b", "duckdb": "355fafbc65133795e6c5e43b", "generic": "355fafbc65133795e6c5e43b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "355fafbc65133795e6c5e43b", +"motherduck": "355fafbc65133795e6c5e43b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "355fafbc65133795e6c5e43b", "postgresql": "355fafbc65133795e6c5e43b", "snowflake": "355fafbc65133795e6c5e43b", @@ -2265,14 +2265,14 @@ { "DuckDB": "0dd2a0d5610068e51e271b9f", "None": "0dd2a0d5610068e51e271b9f", -"bigquery": "0dd2a0d5610068e51e271b9f", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "0dd2a0d5610068e51e271b9f", "duckdb": "0dd2a0d5610068e51e271b9f", "generic": "0dd2a0d5610068e51e271b9f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0dd2a0d5610068e51e271b9f", -"postgres": "0dd2a0d5610068e51e271b9f", -"postgresql": "0dd2a0d5610068e51e271b9f", +"motherduck": "0dd2a0d5610068e51e271b9f", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "b4df93b58afcfa82db9f544e", +"postgresql": "b4df93b58afcfa82db9f544e", "snowflake": "0dd2a0d5610068e51e271b9f", "tsql": "0dd2a0d5610068e51e271b9f" } @@ -2286,8 +2286,8 @@ "databricks": "0703bf71a54942bdaa28406e", "duckdb": "0703bf71a54942bdaa28406e", "generic": "0703bf71a54942bdaa28406e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0703bf71a54942bdaa28406e", +"motherduck": "0703bf71a54942bdaa28406e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0703bf71a54942bdaa28406e", "postgresql": "0703bf71a54942bdaa28406e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -2303,8 +2303,8 @@ "databricks": "6212562845efbc753cb47471", "duckdb": "6212562845efbc753cb47471", "generic": "6212562845efbc753cb47471", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6212562845efbc753cb47471", +"motherduck": "6212562845efbc753cb47471", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6212562845efbc753cb47471", "postgresql": "6212562845efbc753cb47471", "snowflake": "6212562845efbc753cb47471", @@ -2320,8 +2320,8 @@ "databricks": "e998cd8f0f74af0526b75ff0", "duckdb": "e998cd8f0f74af0526b75ff0", "generic": "e998cd8f0f74af0526b75ff0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e998cd8f0f74af0526b75ff0", +"motherduck": "e998cd8f0f74af0526b75ff0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e998cd8f0f74af0526b75ff0", "postgresql": "e998cd8f0f74af0526b75ff0", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -2333,14 +2333,14 @@ { "DuckDB": "de89632e277dbc8c97115419", "None": "de89632e277dbc8c97115419", -"bigquery": "de89632e277dbc8c97115419", +"bigquery": "5abf4ec799a2ec32fb10da7e", "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -2354,8 +2354,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -2365,14 +2365,14 @@ [ "type", { -"DuckDB": "285056becb5d467811be7cd6", +"DuckDB": "0712c33a016f7dd6a37ee011", "None": "285056becb5d467811be7cd6", "bigquery": "0712c33a016f7dd6a37ee011", "databricks": "285056becb5d467811be7cd6", -"duckdb": "285056becb5d467811be7cd6", +"duckdb": "0712c33a016f7dd6a37ee011", "generic": "285056becb5d467811be7cd6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fc10fc558d906a80a6404b7f", +"motherduck": "0712c33a016f7dd6a37ee011", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "285056becb5d467811be7cd6", "postgresql": "285056becb5d467811be7cd6", "snowflake": "0712c33a016f7dd6a37ee011", @@ -2388,8 +2388,8 @@ "databricks": "b4c316e81db1cb6a277b5d27", "duckdb": "1655128a72b1db9af6a89df3", "generic": "1655128a72b1db9af6a89df3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b4c316e81db1cb6a277b5d27", +"motherduck": "1655128a72b1db9af6a89df3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1655128a72b1db9af6a89df3", "postgresql": "1655128a72b1db9af6a89df3", "snowflake": "1655128a72b1db9af6a89df3", @@ -2405,8 +2405,8 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "1d8b945fd793ecdcacb90c21", "generic": "1d8b945fd793ecdcacb90c21", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1d8b945fd793ecdcacb90c21", +"motherduck": "1d8b945fd793ecdcacb90c21", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3efe8bb57c98fcbe74096b3c", "postgresql": "3efe8bb57c98fcbe74096b3c", "snowflake": "1d8b945fd793ecdcacb90c21", @@ -2422,8 +2422,8 @@ "databricks": "3cf4b9eaf303451db16b56f0", "duckdb": "3cf4b9eaf303451db16b56f0", "generic": "3cf4b9eaf303451db16b56f0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3cf4b9eaf303451db16b56f0", +"motherduck": "3cf4b9eaf303451db16b56f0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3cf4b9eaf303451db16b56f0", "postgresql": "3cf4b9eaf303451db16b56f0", "snowflake": "3cf4b9eaf303451db16b56f0", @@ -2439,8 +2439,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -2456,8 +2456,8 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "1e75e5227bea0ae294ac7af1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19bdd92ea0cc5fb028657510", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "19bdd92ea0cc5fb028657510", "postgresql": "19bdd92ea0cc5fb028657510", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -2468,17 +2468,17 @@ "type", { "DuckDB": "d81d8c19074af0e39239164d", -"None": "1fec266134381c760a254d16", -"bigquery": "1fec266134381c760a254d16", -"databricks": "1fec266134381c760a254d16", +"None": "a52676af0c6b750acc33f021", +"bigquery": "1e75e5227bea0ae294ac7af1", +"databricks": "a52676af0c6b750acc33f021", "duckdb": "d81d8c19074af0e39239164d", -"generic": "1fec266134381c760a254d16", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1fec266134381c760a254d16", -"postgres": "1fec266134381c760a254d16", -"postgresql": "1fec266134381c760a254d16", +"generic": "a52676af0c6b750acc33f021", +"motherduck": "d81d8c19074af0e39239164d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a52676af0c6b750acc33f021", +"postgresql": "a52676af0c6b750acc33f021", "snowflake": "1fec266134381c760a254d16", -"tsql": "1fec266134381c760a254d16" +"tsql": "a52676af0c6b750acc33f021" } ], [ @@ -2490,8 +2490,8 @@ "databricks": "3d23f811a03db519b598c815", "duckdb": "3d23f811a03db519b598c815", "generic": "3d23f811a03db519b598c815", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3d23f811a03db519b598c815", +"motherduck": "3d23f811a03db519b598c815", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3d23f811a03db519b598c815", "postgresql": "3d23f811a03db519b598c815", "snowflake": "3d23f811a03db519b598c815", @@ -2503,14 +2503,14 @@ { "DuckDB": "4928771fd9e503a30457d160", "None": "4928771fd9e503a30457d160", -"bigquery": "4928771fd9e503a30457d160", +"bigquery": "67d251c042daee0bb2bf7351", "databricks": "4928771fd9e503a30457d160", "duckdb": "4928771fd9e503a30457d160", "generic": "4928771fd9e503a30457d160", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4928771fd9e503a30457d160", -"postgres": "4928771fd9e503a30457d160", -"postgresql": "4928771fd9e503a30457d160", +"motherduck": "4928771fd9e503a30457d160", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "50ddfb168c08b09892261e82", +"postgresql": "50ddfb168c08b09892261e82", "snowflake": "4928771fd9e503a30457d160", "tsql": "4928771fd9e503a30457d160" } @@ -2524,8 +2524,8 @@ "databricks": "e280c4da8e0aefee0745af65", "duckdb": "e280c4da8e0aefee0745af65", "generic": "e280c4da8e0aefee0745af65", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e280c4da8e0aefee0745af65", +"motherduck": "e280c4da8e0aefee0745af65", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e280c4da8e0aefee0745af65", "postgresql": "e280c4da8e0aefee0745af65", "snowflake": "e280c4da8e0aefee0745af65", @@ -2541,8 +2541,8 @@ "databricks": "5aa51d84ac5e6c7a9306f348", "duckdb": "5aa51d84ac5e6c7a9306f348", "generic": "5aa51d84ac5e6c7a9306f348", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5aa51d84ac5e6c7a9306f348", +"motherduck": "5aa51d84ac5e6c7a9306f348", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5aa51d84ac5e6c7a9306f348", "postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "5aa51d84ac5e6c7a9306f348", @@ -2555,11 +2555,11 @@ "DuckDB": "533aa8bbcadbe01c5e7a5ba7", "None": "533aa8bbcadbe01c5e7a5ba7", "bigquery": "533aa8bbcadbe01c5e7a5ba7", -"databricks": "e8a1e0270aa8ec0f1dc6e35e", +"databricks": "533aa8bbcadbe01c5e7a5ba7", "duckdb": "533aa8bbcadbe01c5e7a5ba7", "generic": "533aa8bbcadbe01c5e7a5ba7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c619dae9f0c9870858ec6530", +"motherduck": "533aa8bbcadbe01c5e7a5ba7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "533aa8bbcadbe01c5e7a5ba7", "postgresql": "533aa8bbcadbe01c5e7a5ba7", "snowflake": "533aa8bbcadbe01c5e7a5ba7", @@ -2575,10 +2575,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -2592,8 +2592,8 @@ "databricks": "d638c2852078bf3facb9dc9e", "duckdb": "207acc46dcc150502155f4a3", "generic": "d638c2852078bf3facb9dc9e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "207acc46dcc150502155f4a3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6c49aec265f259dd95b5310e", "postgresql": "6c49aec265f259dd95b5310e", "snowflake": "ef2c05747b795f92c0b523ee", @@ -2609,8 +2609,8 @@ "databricks": "ad35c4a2523ce8c2f57acf51", "duckdb": "ad35c4a2523ce8c2f57acf51", "generic": "ad35c4a2523ce8c2f57acf51", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ad35c4a2523ce8c2f57acf51", +"motherduck": "ad35c4a2523ce8c2f57acf51", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ad35c4a2523ce8c2f57acf51", "postgresql": "ad35c4a2523ce8c2f57acf51", "snowflake": "ad35c4a2523ce8c2f57acf51", @@ -2622,12 +2622,12 @@ { "DuckDB": "8203bd5901a8ec71ff7c103e", "None": "8203bd5901a8ec71ff7c103e", -"bigquery": "2a0918be53051fe629d9ff8f", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "8203bd5901a8ec71ff7c103e", "duckdb": "8203bd5901a8ec71ff7c103e", "generic": "8203bd5901a8ec71ff7c103e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8203bd5901a8ec71ff7c103e", +"motherduck": "8203bd5901a8ec71ff7c103e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8203bd5901a8ec71ff7c103e", "postgresql": "8203bd5901a8ec71ff7c103e", "snowflake": "8203bd5901a8ec71ff7c103e", @@ -2643,8 +2643,8 @@ "databricks": "f38ef32a483f1c4f89ae309e", "duckdb": "f38ef32a483f1c4f89ae309e", "generic": "f38ef32a483f1c4f89ae309e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f38ef32a483f1c4f89ae309e", +"motherduck": "f38ef32a483f1c4f89ae309e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f38ef32a483f1c4f89ae309e", "postgresql": "f38ef32a483f1c4f89ae309e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -2660,8 +2660,8 @@ "databricks": "cd932c5de0731b5ff7bddd24", "duckdb": "cd932c5de0731b5ff7bddd24", "generic": "cd932c5de0731b5ff7bddd24", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cd932c5de0731b5ff7bddd24", +"motherduck": "cd932c5de0731b5ff7bddd24", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cd932c5de0731b5ff7bddd24", "postgresql": "cd932c5de0731b5ff7bddd24", "snowflake": "cd932c5de0731b5ff7bddd24", @@ -2672,17 +2672,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -2694,10 +2694,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -2711,8 +2711,8 @@ "databricks": "f38ef32a483f1c4f89ae309e", "duckdb": "f38ef32a483f1c4f89ae309e", "generic": "f38ef32a483f1c4f89ae309e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f38ef32a483f1c4f89ae309e", +"motherduck": "f38ef32a483f1c4f89ae309e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f38ef32a483f1c4f89ae309e", "postgresql": "f38ef32a483f1c4f89ae309e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -2728,8 +2728,8 @@ "databricks": "2e28de65a4b680fb5f4ebda9", "duckdb": "2e28de65a4b680fb5f4ebda9", "generic": "2e28de65a4b680fb5f4ebda9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2e28de65a4b680fb5f4ebda9", +"motherduck": "2e28de65a4b680fb5f4ebda9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2e28de65a4b680fb5f4ebda9", "postgresql": "2e28de65a4b680fb5f4ebda9", "snowflake": "2e28de65a4b680fb5f4ebda9", @@ -2745,8 +2745,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -2762,8 +2762,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "ace891b6844cb59efad42031", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "ace891b6844cb59efad42031", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -2779,8 +2779,8 @@ "databricks": "57922064a7dc546cbb50e42b", "duckdb": "57922064a7dc546cbb50e42b", "generic": "57922064a7dc546cbb50e42b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "57922064a7dc546cbb50e42b", +"motherduck": "57922064a7dc546cbb50e42b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "57922064a7dc546cbb50e42b", "postgresql": "57922064a7dc546cbb50e42b", "snowflake": "57922064a7dc546cbb50e42b", @@ -2792,12 +2792,12 @@ { "DuckDB": "e08a957777bd278f921ca0ee", "None": "e08a957777bd278f921ca0ee", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "e08a957777bd278f921ca0ee", "duckdb": "e08a957777bd278f921ca0ee", "generic": "e08a957777bd278f921ca0ee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e08a957777bd278f921ca0ee", +"motherduck": "e08a957777bd278f921ca0ee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e08a957777bd278f921ca0ee", "postgresql": "e08a957777bd278f921ca0ee", "snowflake": "e08a957777bd278f921ca0ee", @@ -2813,8 +2813,8 @@ "databricks": "2785bf366213936ce93d91f2", "duckdb": "5980124ff4dad5573f810a21", "generic": "2785bf366213936ce93d91f2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "5980124ff4dad5573f810a21", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5980124ff4dad5573f810a21", "postgresql": "5980124ff4dad5573f810a21", "snowflake": "b53e32783b8b9274e350988b", @@ -2830,8 +2830,8 @@ "databricks": "055c9340448c8378561480dd", "duckdb": "055c9340448c8378561480dd", "generic": "055c9340448c8378561480dd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "055c9340448c8378561480dd", +"motherduck": "055c9340448c8378561480dd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "055c9340448c8378561480dd", "postgresql": "055c9340448c8378561480dd", "snowflake": "055c9340448c8378561480dd", @@ -2847,8 +2847,8 @@ "databricks": "ab8c248625776c7ac340119c", "duckdb": "ab8c248625776c7ac340119c", "generic": "ab8c248625776c7ac340119c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ab8c248625776c7ac340119c", +"motherduck": "ab8c248625776c7ac340119c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ab8c248625776c7ac340119c", "postgresql": "ab8c248625776c7ac340119c", "snowflake": "ab8c248625776c7ac340119c", @@ -2864,10 +2864,10 @@ "databricks": "d23bf939a7eb8e49c7e6867a", "duckdb": "d23bf939a7eb8e49c7e6867a", "generic": "d23bf939a7eb8e49c7e6867a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d23bf939a7eb8e49c7e6867a", -"postgres": "d23bf939a7eb8e49c7e6867a", -"postgresql": "d23bf939a7eb8e49c7e6867a", +"motherduck": "d23bf939a7eb8e49c7e6867a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "71f4f8fbb5f5c537d895ceb4", +"postgresql": "71f4f8fbb5f5c537d895ceb4", "snowflake": "d23bf939a7eb8e49c7e6867a", "tsql": "d23bf939a7eb8e49c7e6867a" } @@ -2881,8 +2881,8 @@ "databricks": "d79c3ac70093cb4cb531e71c", "duckdb": "d79c3ac70093cb4cb531e71c", "generic": "d79c3ac70093cb4cb531e71c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d79c3ac70093cb4cb531e71c", +"motherduck": "d79c3ac70093cb4cb531e71c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d79c3ac70093cb4cb531e71c", "postgresql": "d79c3ac70093cb4cb531e71c", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -2898,8 +2898,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -2915,8 +2915,8 @@ "databricks": "782ae75a1700e1a48355b077", "duckdb": "782ae75a1700e1a48355b077", "generic": "782ae75a1700e1a48355b077", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "782ae75a1700e1a48355b077", +"motherduck": "782ae75a1700e1a48355b077", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "782ae75a1700e1a48355b077", "postgresql": "782ae75a1700e1a48355b077", "snowflake": "782ae75a1700e1a48355b077", @@ -2928,12 +2928,12 @@ { "DuckDB": "28eb0d6de9724959ce5ba43e", "None": "28eb0d6de9724959ce5ba43e", -"bigquery": "f28a96f0eb38ad8874f6ec5d", +"bigquery": "5c28019dce48a74708c90a76", "databricks": "28eb0d6de9724959ce5ba43e", "duckdb": "28eb0d6de9724959ce5ba43e", "generic": "28eb0d6de9724959ce5ba43e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "28eb0d6de9724959ce5ba43e", +"motherduck": "28eb0d6de9724959ce5ba43e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "28eb0d6de9724959ce5ba43e", "postgresql": "28eb0d6de9724959ce5ba43e", "snowflake": "28eb0d6de9724959ce5ba43e", @@ -2949,8 +2949,8 @@ "databricks": "dcd1c844f2d13f3b6788d1a6", "duckdb": "dcd1c844f2d13f3b6788d1a6", "generic": "dcd1c844f2d13f3b6788d1a6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "dcd1c844f2d13f3b6788d1a6", +"motherduck": "dcd1c844f2d13f3b6788d1a6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "dcd1c844f2d13f3b6788d1a6", "postgresql": "dcd1c844f2d13f3b6788d1a6", "snowflake": "dcd1c844f2d13f3b6788d1a6", @@ -2966,8 +2966,8 @@ "databricks": "304be1d51ad99bfab3750f57", "duckdb": "304be1d51ad99bfab3750f57", "generic": "304be1d51ad99bfab3750f57", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "304be1d51ad99bfab3750f57", +"motherduck": "304be1d51ad99bfab3750f57", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "304be1d51ad99bfab3750f57", "postgresql": "304be1d51ad99bfab3750f57", "snowflake": "304be1d51ad99bfab3750f57", @@ -2983,8 +2983,8 @@ "databricks": "3e42d732ee33bbd1424911a7", "duckdb": "7466f0581624f38e4d1e972d", "generic": "f25507ff493aa410f2d2a6d6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f25507ff493aa410f2d2a6d6", +"motherduck": "7466f0581624f38e4d1e972d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f25507ff493aa410f2d2a6d6", "postgresql": "f25507ff493aa410f2d2a6d6", "snowflake": "60ad8b0a5cb3592bd3b0fc8f", @@ -3000,8 +3000,8 @@ "databricks": "f4c43a87a78970bca1f88b09", "duckdb": "f4c43a87a78970bca1f88b09", "generic": "f4c43a87a78970bca1f88b09", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f4c43a87a78970bca1f88b09", +"motherduck": "f4c43a87a78970bca1f88b09", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f4c43a87a78970bca1f88b09", "postgresql": "f4c43a87a78970bca1f88b09", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -3017,8 +3017,8 @@ "databricks": "2427f5522575cdc3d6a74e4c", "duckdb": "2427f5522575cdc3d6a74e4c", "generic": "2427f5522575cdc3d6a74e4c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2427f5522575cdc3d6a74e4c", +"motherduck": "2427f5522575cdc3d6a74e4c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2427f5522575cdc3d6a74e4c", "postgresql": "2427f5522575cdc3d6a74e4c", "snowflake": "2427f5522575cdc3d6a74e4c", @@ -3029,34 +3029,34 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ "type", { "DuckDB": "3af3f9124a8649e4f72030c1", -"None": "3af3f9124a8649e4f72030c1", +"None": "8191fff105ab0743bf9ffd39", "bigquery": "8191fff105ab0743bf9ffd39", "databricks": "8191fff105ab0743bf9ffd39", "duckdb": "3af3f9124a8649e4f72030c1", -"generic": "3af3f9124a8649e4f72030c1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8191fff105ab0743bf9ffd39", -"postgres": "3af3f9124a8649e4f72030c1", -"postgresql": "3af3f9124a8649e4f72030c1", +"generic": "8191fff105ab0743bf9ffd39", +"motherduck": "3af3f9124a8649e4f72030c1", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "23cc34d931e18f55168723f0", +"postgresql": "23cc34d931e18f55168723f0", "snowflake": "3af3f9124a8649e4f72030c1", -"tsql": "3af3f9124a8649e4f72030c1" +"tsql": "8191fff105ab0743bf9ffd39" } ], [ @@ -3064,14 +3064,14 @@ { "DuckDB": "e46d4be44ab9e500e9190d26", "None": "e46d4be44ab9e500e9190d26", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -3081,12 +3081,12 @@ { "DuckDB": "5c28019dce48a74708c90a76", "None": "5c28019dce48a74708c90a76", -"bigquery": "f28a96f0eb38ad8874f6ec5d", +"bigquery": "70fb4728c3adcf6dbe4975d5", "databricks": "5c28019dce48a74708c90a76", "duckdb": "5c28019dce48a74708c90a76", "generic": "5c28019dce48a74708c90a76", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "5c28019dce48a74708c90a76", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5c28019dce48a74708c90a76", "postgresql": "5c28019dce48a74708c90a76", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -3102,8 +3102,8 @@ "databricks": "0dcd6a19b7dc6f6b6d4a5006", "duckdb": "0dcd6a19b7dc6f6b6d4a5006", "generic": "0dcd6a19b7dc6f6b6d4a5006", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0dcd6a19b7dc6f6b6d4a5006", +"motherduck": "0dcd6a19b7dc6f6b6d4a5006", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0dcd6a19b7dc6f6b6d4a5006", "postgresql": "0dcd6a19b7dc6f6b6d4a5006", "snowflake": "0dcd6a19b7dc6f6b6d4a5006", @@ -3119,8 +3119,8 @@ "databricks": "c2700ca3573352821e09af03", "duckdb": "c2700ca3573352821e09af03", "generic": "c2700ca3573352821e09af03", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c2700ca3573352821e09af03", +"motherduck": "c2700ca3573352821e09af03", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c2700ca3573352821e09af03", "postgresql": "c2700ca3573352821e09af03", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -3132,14 +3132,14 @@ { "DuckDB": "b561884132dbe7e42b719110", "None": "b561884132dbe7e42b719110", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "b561884132dbe7e42b719110", "duckdb": "b561884132dbe7e42b719110", "generic": "b561884132dbe7e42b719110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b561884132dbe7e42b719110", -"postgres": "b561884132dbe7e42b719110", -"postgresql": "b561884132dbe7e42b719110", +"motherduck": "b561884132dbe7e42b719110", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5aa51d84ac5e6c7a9306f348", +"postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "b561884132dbe7e42b719110", "tsql": "b561884132dbe7e42b719110" } @@ -3153,8 +3153,8 @@ "databricks": "d7b74701deb8b87c32deb7a6", "duckdb": "d7b74701deb8b87c32deb7a6", "generic": "d7b74701deb8b87c32deb7a6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d7b74701deb8b87c32deb7a6", +"motherduck": "d7b74701deb8b87c32deb7a6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d7b74701deb8b87c32deb7a6", "postgresql": "d7b74701deb8b87c32deb7a6", "snowflake": "d7b74701deb8b87c32deb7a6", @@ -3170,8 +3170,8 @@ "databricks": "a6b64a929834c52f65384447", "duckdb": "a6b64a929834c52f65384447", "generic": "a6b64a929834c52f65384447", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a6b64a929834c52f65384447", +"motherduck": "a6b64a929834c52f65384447", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a6b64a929834c52f65384447", "postgresql": "a6b64a929834c52f65384447", "snowflake": "a6b64a929834c52f65384447", @@ -3182,17 +3182,17 @@ "type", { "DuckDB": "d81d8c19074af0e39239164d", -"None": "1fec266134381c760a254d16", -"bigquery": "1fec266134381c760a254d16", -"databricks": "1fec266134381c760a254d16", +"None": "a52676af0c6b750acc33f021", +"bigquery": "1e75e5227bea0ae294ac7af1", +"databricks": "a52676af0c6b750acc33f021", "duckdb": "d81d8c19074af0e39239164d", -"generic": "1fec266134381c760a254d16", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1fec266134381c760a254d16", -"postgres": "1fec266134381c760a254d16", -"postgresql": "1fec266134381c760a254d16", +"generic": "a52676af0c6b750acc33f021", +"motherduck": "d81d8c19074af0e39239164d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a52676af0c6b750acc33f021", +"postgresql": "a52676af0c6b750acc33f021", "snowflake": "1fec266134381c760a254d16", -"tsql": "1fec266134381c760a254d16" +"tsql": "a52676af0c6b750acc33f021" } ], [ @@ -3200,12 +3200,12 @@ { "DuckDB": "62368fc15cefd5807807b209", "None": "62368fc15cefd5807807b209", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "62368fc15cefd5807807b209", "duckdb": "62368fc15cefd5807807b209", "generic": "62368fc15cefd5807807b209", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "62368fc15cefd5807807b209", +"motherduck": "62368fc15cefd5807807b209", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "62368fc15cefd5807807b209", "postgresql": "62368fc15cefd5807807b209", "snowflake": "62368fc15cefd5807807b209", @@ -3221,8 +3221,8 @@ "databricks": "fbbf6dbffd81c1b899b2f41b", "duckdb": "fbbf6dbffd81c1b899b2f41b", "generic": "fbbf6dbffd81c1b899b2f41b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fbbf6dbffd81c1b899b2f41b", +"motherduck": "fbbf6dbffd81c1b899b2f41b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fbbf6dbffd81c1b899b2f41b", "postgresql": "fbbf6dbffd81c1b899b2f41b", "snowflake": "fbbf6dbffd81c1b899b2f41b", @@ -3238,8 +3238,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -3255,8 +3255,8 @@ "databricks": "a2c63b7e92b578944818d750", "duckdb": "a2c63b7e92b578944818d750", "generic": "a2c63b7e92b578944818d750", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a2c63b7e92b578944818d750", +"motherduck": "a2c63b7e92b578944818d750", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a2c63b7e92b578944818d750", "postgresql": "a2c63b7e92b578944818d750", "snowflake": "a2c63b7e92b578944818d750", @@ -3272,8 +3272,8 @@ "databricks": "a3d6f52ec64a728636793faa", "duckdb": "a3d6f52ec64a728636793faa", "generic": "a3d6f52ec64a728636793faa", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a3d6f52ec64a728636793faa", +"motherduck": "a3d6f52ec64a728636793faa", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a3d6f52ec64a728636793faa", "postgresql": "a3d6f52ec64a728636793faa", "snowflake": "a3d6f52ec64a728636793faa", @@ -3289,8 +3289,8 @@ "databricks": "dcb00b7053ffe69fe3ce99cd", "duckdb": "c7b697bbfa82dd2821ad64e9", "generic": "c7b697bbfa82dd2821ad64e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "dcb00b7053ffe69fe3ce99cd", +"motherduck": "c7b697bbfa82dd2821ad64e9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c7b697bbfa82dd2821ad64e9", "postgresql": "c7b697bbfa82dd2821ad64e9", "snowflake": "c7b697bbfa82dd2821ad64e9", @@ -3306,8 +3306,8 @@ "databricks": "717cf79ef777823eb3576deb", "duckdb": "717cf79ef777823eb3576deb", "generic": "717cf79ef777823eb3576deb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "717cf79ef777823eb3576deb", +"motherduck": "717cf79ef777823eb3576deb", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "717cf79ef777823eb3576deb", "postgresql": "717cf79ef777823eb3576deb", "snowflake": "717cf79ef777823eb3576deb", @@ -3323,8 +3323,8 @@ "databricks": "c1dad3a1ff61e56cb10b9cdf", "duckdb": "c1dad3a1ff61e56cb10b9cdf", "generic": "c1dad3a1ff61e56cb10b9cdf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c1dad3a1ff61e56cb10b9cdf", +"motherduck": "c1dad3a1ff61e56cb10b9cdf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c1dad3a1ff61e56cb10b9cdf", "postgresql": "c1dad3a1ff61e56cb10b9cdf", "snowflake": "c1dad3a1ff61e56cb10b9cdf", @@ -3340,8 +3340,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -3357,8 +3357,8 @@ "databricks": "17a6d1702d6997aa4e447f46", "duckdb": "755657fbcced1de4551fb370", "generic": "17a6d1702d6997aa4e447f46", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "17a6d1702d6997aa4e447f46", +"motherduck": "755657fbcced1de4551fb370", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "17a6d1702d6997aa4e447f46", "postgresql": "17a6d1702d6997aa4e447f46", "snowflake": "17a6d1702d6997aa4e447f46", @@ -3374,8 +3374,8 @@ "databricks": "c05190b1f2b5d7003e7076da", "duckdb": "c05190b1f2b5d7003e7076da", "generic": "c05190b1f2b5d7003e7076da", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c05190b1f2b5d7003e7076da", +"motherduck": "c05190b1f2b5d7003e7076da", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c05190b1f2b5d7003e7076da", "postgresql": "c05190b1f2b5d7003e7076da", "snowflake": "c05190b1f2b5d7003e7076da", @@ -3386,17 +3386,17 @@ "type", { "DuckDB": "fa45b7e4a9ef3b5a9c5781af", -"None": "fa45b7e4a9ef3b5a9c5781af", -"bigquery": "fa45b7e4a9ef3b5a9c5781af", -"databricks": "fa45b7e4a9ef3b5a9c5781af", +"None": "ebe2513b6cb4001e42cc464b", +"bigquery": "0c43dc837a50933667588ef1", +"databricks": "ebe2513b6cb4001e42cc464b", "duckdb": "fa45b7e4a9ef3b5a9c5781af", -"generic": "fa45b7e4a9ef3b5a9c5781af", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fa45b7e4a9ef3b5a9c5781af", +"generic": "ebe2513b6cb4001e42cc464b", +"motherduck": "fa45b7e4a9ef3b5a9c5781af", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fa45b7e4a9ef3b5a9c5781af", "postgresql": "fa45b7e4a9ef3b5a9c5781af", "snowflake": "fa45b7e4a9ef3b5a9c5781af", -"tsql": "fa45b7e4a9ef3b5a9c5781af" +"tsql": "ebe2513b6cb4001e42cc464b" } ], [ @@ -3408,8 +3408,8 @@ "databricks": "1bdf5908ca249b2331a0427c", "duckdb": "1bdf5908ca249b2331a0427c", "generic": "1bdf5908ca249b2331a0427c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1bdf5908ca249b2331a0427c", +"motherduck": "1bdf5908ca249b2331a0427c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1bdf5908ca249b2331a0427c", "postgresql": "1bdf5908ca249b2331a0427c", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -3425,8 +3425,8 @@ "databricks": "bb7975dcb1f2ac7cdd149b0b", "duckdb": "bb7975dcb1f2ac7cdd149b0b", "generic": "bb7975dcb1f2ac7cdd149b0b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "bb7975dcb1f2ac7cdd149b0b", +"motherduck": "bb7975dcb1f2ac7cdd149b0b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "bb7975dcb1f2ac7cdd149b0b", "postgresql": "bb7975dcb1f2ac7cdd149b0b", "snowflake": "bb7975dcb1f2ac7cdd149b0b", @@ -3442,8 +3442,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -3459,8 +3459,8 @@ "databricks": "74ed18299daa6faf5c9533e2", "duckdb": "74ed18299daa6faf5c9533e2", "generic": "74ed18299daa6faf5c9533e2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "74ed18299daa6faf5c9533e2", +"motherduck": "74ed18299daa6faf5c9533e2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "74ed18299daa6faf5c9533e2", "postgresql": "74ed18299daa6faf5c9533e2", "snowflake": "74ed18299daa6faf5c9533e2", @@ -3476,8 +3476,8 @@ "databricks": "60a23b7dcae6c79f4de83068", "duckdb": "60a23b7dcae6c79f4de83068", "generic": "60a23b7dcae6c79f4de83068", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "60a23b7dcae6c79f4de83068", +"motherduck": "60a23b7dcae6c79f4de83068", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "60a23b7dcae6c79f4de83068", "postgresql": "60a23b7dcae6c79f4de83068", "snowflake": "60a23b7dcae6c79f4de83068", @@ -3489,12 +3489,12 @@ { "DuckDB": "0f799a95a4f5ef502897f02c", "None": "0f799a95a4f5ef502897f02c", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "0f799a95a4f5ef502897f02c", "duckdb": "0f799a95a4f5ef502897f02c", "generic": "0f799a95a4f5ef502897f02c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0f799a95a4f5ef502897f02c", +"motherduck": "0f799a95a4f5ef502897f02c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0f799a95a4f5ef502897f02c", "postgresql": "0f799a95a4f5ef502897f02c", "snowflake": "0f799a95a4f5ef502897f02c", @@ -3510,8 +3510,8 @@ "databricks": "5d0a19a893dbf0c1e6e9f15c", "duckdb": "5d0a19a893dbf0c1e6e9f15c", "generic": "5d0a19a893dbf0c1e6e9f15c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d0a19a893dbf0c1e6e9f15c", +"motherduck": "5d0a19a893dbf0c1e6e9f15c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5d0a19a893dbf0c1e6e9f15c", "postgresql": "5d0a19a893dbf0c1e6e9f15c", "snowflake": "5d0a19a893dbf0c1e6e9f15c", @@ -3523,14 +3523,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -3540,12 +3540,12 @@ { "DuckDB": "855e2727b4a8cb5d2711f102", "None": "855e2727b4a8cb5d2711f102", -"bigquery": "855e2727b4a8cb5d2711f102", +"bigquery": "01e56f2a28ba32841a6d614a", "databricks": "855e2727b4a8cb5d2711f102", "duckdb": "855e2727b4a8cb5d2711f102", "generic": "855e2727b4a8cb5d2711f102", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "855e2727b4a8cb5d2711f102", +"motherduck": "855e2727b4a8cb5d2711f102", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "855e2727b4a8cb5d2711f102", "postgresql": "855e2727b4a8cb5d2711f102", "snowflake": "855e2727b4a8cb5d2711f102", @@ -3556,17 +3556,17 @@ "type", { "DuckDB": "1ebac487198b6c90b027faab", -"None": "1ebac487198b6c90b027faab", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "1ebac487198b6c90b027faab", +"None": "79278352c17c9de0f5a28af5", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "79278352c17c9de0f5a28af5", "duckdb": "1ebac487198b6c90b027faab", -"generic": "1ebac487198b6c90b027faab", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1ebac487198b6c90b027faab", -"postgres": "1ebac487198b6c90b027faab", -"postgresql": "1ebac487198b6c90b027faab", -"snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "c692d974ee3f362ecb38f27c" +"generic": "79278352c17c9de0f5a28af5", +"motherduck": "1ebac487198b6c90b027faab", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "79278352c17c9de0f5a28af5", +"postgresql": "79278352c17c9de0f5a28af5", +"snowflake": "97a20344d811fb77c7690863", +"tsql": "79278352c17c9de0f5a28af5" } ], [ @@ -3575,11 +3575,11 @@ "DuckDB": "9c2cff8be7225cf79883ca65", "None": "9c2cff8be7225cf79883ca65", "bigquery": "9c2cff8be7225cf79883ca65", -"databricks": "901ac89f8d9ec18bd3a61e4b", +"databricks": "9c2cff8be7225cf79883ca65", "duckdb": "9c2cff8be7225cf79883ca65", "generic": "9c2cff8be7225cf79883ca65", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "901ac89f8d9ec18bd3a61e4b", +"motherduck": "9c2cff8be7225cf79883ca65", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9c2cff8be7225cf79883ca65", "postgresql": "9c2cff8be7225cf79883ca65", "snowflake": "9c2cff8be7225cf79883ca65", @@ -3595,8 +3595,8 @@ "databricks": "74f50f8ec759a3cc65ac027d", "duckdb": "74f50f8ec759a3cc65ac027d", "generic": "74f50f8ec759a3cc65ac027d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "74f50f8ec759a3cc65ac027d", +"motherduck": "74f50f8ec759a3cc65ac027d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "74f50f8ec759a3cc65ac027d", "postgresql": "74f50f8ec759a3cc65ac027d", "snowflake": "74f50f8ec759a3cc65ac027d", @@ -3612,8 +3612,8 @@ "databricks": "3dbbe73ee4310c73030e8110", "duckdb": "3dbbe73ee4310c73030e8110", "generic": "3dbbe73ee4310c73030e8110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3dbbe73ee4310c73030e8110", +"motherduck": "3dbbe73ee4310c73030e8110", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3dbbe73ee4310c73030e8110", "postgresql": "3dbbe73ee4310c73030e8110", "snowflake": "f43dac38f34a1c0618a3f812", @@ -3629,8 +3629,8 @@ "databricks": "0dcd6a19b7dc6f6b6d4a5006", "duckdb": "0dcd6a19b7dc6f6b6d4a5006", "generic": "0dcd6a19b7dc6f6b6d4a5006", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0dcd6a19b7dc6f6b6d4a5006", +"motherduck": "0dcd6a19b7dc6f6b6d4a5006", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0dcd6a19b7dc6f6b6d4a5006", "postgresql": "0dcd6a19b7dc6f6b6d4a5006", "snowflake": "0dcd6a19b7dc6f6b6d4a5006", @@ -3646,8 +3646,8 @@ "databricks": "7ffb4db35f5f9871e8c9a084", "duckdb": "7ffb4db35f5f9871e8c9a084", "generic": "7ffb4db35f5f9871e8c9a084", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7ffb4db35f5f9871e8c9a084", +"motherduck": "7ffb4db35f5f9871e8c9a084", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7ffb4db35f5f9871e8c9a084", "postgresql": "7ffb4db35f5f9871e8c9a084", "snowflake": "7ffb4db35f5f9871e8c9a084", @@ -3663,8 +3663,8 @@ "databricks": "d79c3ac70093cb4cb531e71c", "duckdb": "d79c3ac70093cb4cb531e71c", "generic": "d79c3ac70093cb4cb531e71c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d79c3ac70093cb4cb531e71c", +"motherduck": "d79c3ac70093cb4cb531e71c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d79c3ac70093cb4cb531e71c", "postgresql": "d79c3ac70093cb4cb531e71c", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -3675,17 +3675,17 @@ "type", { "DuckDB": "3147a9e06daa6de4a4df5abc", -"None": "3147a9e06daa6de4a4df5abc", -"bigquery": "f276e907770196606577c932", -"databricks": "3147a9e06daa6de4a4df5abc", +"None": "da0625706f12b764a6912278", +"bigquery": "b0477b36767a62145aa9158c", +"databricks": "da0625706f12b764a6912278", "duckdb": "3147a9e06daa6de4a4df5abc", -"generic": "3147a9e06daa6de4a4df5abc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3147a9e06daa6de4a4df5abc", +"generic": "da0625706f12b764a6912278", +"motherduck": "3147a9e06daa6de4a4df5abc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3147a9e06daa6de4a4df5abc", "postgresql": "3147a9e06daa6de4a4df5abc", "snowflake": "67b5874a2c569226c490211f", -"tsql": "3147a9e06daa6de4a4df5abc" +"tsql": "da0625706f12b764a6912278" } ], [ @@ -3697,8 +3697,8 @@ "databricks": "02e0b2ed25f32a8d09350a23", "duckdb": "7afe04283391fb5bd9bd1f6e", "generic": "6fad076e9d13c0d09c490402", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "7afe04283391fb5bd9bd1f6e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7afe04283391fb5bd9bd1f6e", "postgresql": "7afe04283391fb5bd9bd1f6e", "snowflake": "dddc37362726cca4f2353a8d", @@ -3714,8 +3714,8 @@ "databricks": "802f1c1fcb97ddd5679172d2", "duckdb": "802f1c1fcb97ddd5679172d2", "generic": "802f1c1fcb97ddd5679172d2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "802f1c1fcb97ddd5679172d2", +"motherduck": "802f1c1fcb97ddd5679172d2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "802f1c1fcb97ddd5679172d2", "postgresql": "802f1c1fcb97ddd5679172d2", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -3731,8 +3731,8 @@ "databricks": "7552f1f36764fa5333dc3b01", "duckdb": "71cce31a35d7039dcd2aa86d", "generic": "71cce31a35d7039dcd2aa86d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "71cce31a35d7039dcd2aa86d", +"motherduck": "71cce31a35d7039dcd2aa86d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "71cce31a35d7039dcd2aa86d", "postgresql": "71cce31a35d7039dcd2aa86d", "snowflake": "aa1ac5b2c999b497d54fa520", @@ -3744,12 +3744,12 @@ { "DuckDB": "aae2b1fe6f2d9807ecde412b", "None": "aae2b1fe6f2d9807ecde412b", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "aae2b1fe6f2d9807ecde412b", "duckdb": "aae2b1fe6f2d9807ecde412b", "generic": "aae2b1fe6f2d9807ecde412b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aae2b1fe6f2d9807ecde412b", +"motherduck": "aae2b1fe6f2d9807ecde412b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "aae2b1fe6f2d9807ecde412b", "postgresql": "aae2b1fe6f2d9807ecde412b", "snowflake": "aae2b1fe6f2d9807ecde412b", @@ -3765,8 +3765,8 @@ "databricks": "4169d9651c2a3667fc561f32", "duckdb": "4169d9651c2a3667fc561f32", "generic": "4169d9651c2a3667fc561f32", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4169d9651c2a3667fc561f32", +"motherduck": "4169d9651c2a3667fc561f32", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4169d9651c2a3667fc561f32", "postgresql": "4169d9651c2a3667fc561f32", "snowflake": "b210f8eb26c37b422f786c6b", @@ -3782,8 +3782,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "8441d00030df06ad6a5534d3", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "8441d00030df06ad6a5534d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -3799,8 +3799,8 @@ "databricks": "6533f23a0660791970dbbbc8", "duckdb": "6533f23a0660791970dbbbc8", "generic": "6533f23a0660791970dbbbc8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6533f23a0660791970dbbbc8", +"motherduck": "6533f23a0660791970dbbbc8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6533f23a0660791970dbbbc8", "postgresql": "6533f23a0660791970dbbbc8", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -3816,8 +3816,8 @@ "databricks": "6d07fc2f489d414e7eb90262", "duckdb": "9d0ae138704cb97e3fe4d105", "generic": "9d0ae138704cb97e3fe4d105", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6d07fc2f489d414e7eb90262", +"motherduck": "9d0ae138704cb97e3fe4d105", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9d0ae138704cb97e3fe4d105", "postgresql": "9d0ae138704cb97e3fe4d105", "snowflake": "9d0ae138704cb97e3fe4d105", @@ -3829,14 +3829,14 @@ { "DuckDB": "de89632e277dbc8c97115419", "None": "de89632e277dbc8c97115419", -"bigquery": "de89632e277dbc8c97115419", +"bigquery": "5abf4ec799a2ec32fb10da7e", "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -3845,34 +3845,34 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ "type", { "DuckDB": "2c44dc35fd1ef8701101802e", -"None": "2c44dc35fd1ef8701101802e", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "2c44dc35fd1ef8701101802e", +"None": "8441d00030df06ad6a5534d3", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "8441d00030df06ad6a5534d3", "duckdb": "2c44dc35fd1ef8701101802e", -"generic": "2c44dc35fd1ef8701101802e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2c44dc35fd1ef8701101802e", -"postgres": "2c44dc35fd1ef8701101802e", -"postgresql": "2c44dc35fd1ef8701101802e", +"generic": "8441d00030df06ad6a5534d3", +"motherduck": "2c44dc35fd1ef8701101802e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8441d00030df06ad6a5534d3", +"postgresql": "8441d00030df06ad6a5534d3", "snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "2c44dc35fd1ef8701101802e" +"tsql": "8441d00030df06ad6a5534d3" } ], [ @@ -3884,8 +3884,8 @@ "databricks": "9917d6c8c04307304904313b", "duckdb": "9917d6c8c04307304904313b", "generic": "9917d6c8c04307304904313b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9917d6c8c04307304904313b", +"motherduck": "9917d6c8c04307304904313b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9917d6c8c04307304904313b", "postgresql": "9917d6c8c04307304904313b", "snowflake": "9917d6c8c04307304904313b", @@ -3896,17 +3896,17 @@ "type", { "DuckDB": "8a3f094f18fb4047f0febf59", -"None": "e51e1eecca3e36c76e34498f", -"bigquery": "5c28019dce48a74708c90a76", -"databricks": "e51e1eecca3e36c76e34498f", +"None": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", +"databricks": "38b2ec94bf02be40007ce525", "duckdb": "8a3f094f18fb4047f0febf59", -"generic": "e51e1eecca3e36c76e34498f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "84fca9ac893777959cfd715c", -"postgres": "e51e1eecca3e36c76e34498f", -"postgresql": "e51e1eecca3e36c76e34498f", +"generic": "38b2ec94bf02be40007ce525", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "e51e1eecca3e36c76e34498f", -"tsql": "8adf69b4c11191257f2953cc" +"tsql": "38b2ec94bf02be40007ce525" } ], [ @@ -3914,14 +3914,14 @@ { "DuckDB": "4b356542044f1267fcfc487a", "None": "4b356542044f1267fcfc487a", -"bigquery": "4b356542044f1267fcfc487a", +"bigquery": "a5656d70e208254d1d3e9b4f", "databricks": "4b356542044f1267fcfc487a", "duckdb": "4b356542044f1267fcfc487a", "generic": "4b356542044f1267fcfc487a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4b356542044f1267fcfc487a", -"postgres": "4b356542044f1267fcfc487a", -"postgresql": "4b356542044f1267fcfc487a", +"motherduck": "4b356542044f1267fcfc487a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a5656d70e208254d1d3e9b4f", +"postgresql": "a5656d70e208254d1d3e9b4f", "snowflake": "4b356542044f1267fcfc487a", "tsql": "4b356542044f1267fcfc487a" } @@ -3935,8 +3935,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -3948,14 +3948,14 @@ { "DuckDB": "afc451102e0ebe7f507119b9", "None": "afc451102e0ebe7f507119b9", -"bigquery": "afc451102e0ebe7f507119b9", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "afc451102e0ebe7f507119b9", "duckdb": "afc451102e0ebe7f507119b9", "generic": "afc451102e0ebe7f507119b9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "afc451102e0ebe7f507119b9", -"postgres": "afc451102e0ebe7f507119b9", -"postgresql": "afc451102e0ebe7f507119b9", +"motherduck": "afc451102e0ebe7f507119b9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ff3f47e5455500158628a360", +"postgresql": "ff3f47e5455500158628a360", "snowflake": "afc451102e0ebe7f507119b9", "tsql": "afc451102e0ebe7f507119b9" } @@ -3969,8 +3969,8 @@ "databricks": "74ed18299daa6faf5c9533e2", "duckdb": "74ed18299daa6faf5c9533e2", "generic": "74ed18299daa6faf5c9533e2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "74ed18299daa6faf5c9533e2", +"motherduck": "74ed18299daa6faf5c9533e2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "74ed18299daa6faf5c9533e2", "postgresql": "74ed18299daa6faf5c9533e2", "snowflake": "74ed18299daa6faf5c9533e2", @@ -3986,8 +3986,8 @@ "databricks": "f43dac38f34a1c0618a3f812", "duckdb": "f43dac38f34a1c0618a3f812", "generic": "f43dac38f34a1c0618a3f812", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f43dac38f34a1c0618a3f812", +"motherduck": "f43dac38f34a1c0618a3f812", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f43dac38f34a1c0618a3f812", "postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "f43dac38f34a1c0618a3f812", @@ -4003,8 +4003,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -4016,14 +4016,14 @@ { "DuckDB": "60b39a68a18438603dd5496d", "None": "60b39a68a18438603dd5496d", -"bigquery": "60b39a68a18438603dd5496d", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "60b39a68a18438603dd5496d", "duckdb": "60b39a68a18438603dd5496d", "generic": "60b39a68a18438603dd5496d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "60b39a68a18438603dd5496d", -"postgres": "60b39a68a18438603dd5496d", -"postgresql": "60b39a68a18438603dd5496d", +"motherduck": "60b39a68a18438603dd5496d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "7a007e6ff9e9465c9d7fadea", +"postgresql": "7a007e6ff9e9465c9d7fadea", "snowflake": "60b39a68a18438603dd5496d", "tsql": "60b39a68a18438603dd5496d" } @@ -4037,10 +4037,10 @@ "databricks": "b561884132dbe7e42b719110", "duckdb": "b561884132dbe7e42b719110", "generic": "b561884132dbe7e42b719110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b561884132dbe7e42b719110", -"postgres": "b561884132dbe7e42b719110", -"postgresql": "b561884132dbe7e42b719110", +"motherduck": "b561884132dbe7e42b719110", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5aa51d84ac5e6c7a9306f348", +"postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "b561884132dbe7e42b719110", "tsql": "b561884132dbe7e42b719110" } @@ -4054,8 +4054,8 @@ "databricks": "0b9d9879e289ea9a6a3e3e70", "duckdb": "0b9d9879e289ea9a6a3e3e70", "generic": "0b9d9879e289ea9a6a3e3e70", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0b9d9879e289ea9a6a3e3e70", +"motherduck": "0b9d9879e289ea9a6a3e3e70", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0b9d9879e289ea9a6a3e3e70", "postgresql": "0b9d9879e289ea9a6a3e3e70", "snowflake": "0b9d9879e289ea9a6a3e3e70", @@ -4071,8 +4071,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -4088,8 +4088,8 @@ "databricks": "c6197f1da8168ac56d61807b", "duckdb": "c6197f1da8168ac56d61807b", "generic": "c6197f1da8168ac56d61807b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6197f1da8168ac56d61807b", +"motherduck": "c6197f1da8168ac56d61807b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6197f1da8168ac56d61807b", "postgresql": "c6197f1da8168ac56d61807b", "snowflake": "c6197f1da8168ac56d61807b", @@ -4101,14 +4101,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -4122,8 +4122,8 @@ "databricks": "e998cd8f0f74af0526b75ff0", "duckdb": "e998cd8f0f74af0526b75ff0", "generic": "e998cd8f0f74af0526b75ff0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e998cd8f0f74af0526b75ff0", +"motherduck": "e998cd8f0f74af0526b75ff0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e998cd8f0f74af0526b75ff0", "postgresql": "e998cd8f0f74af0526b75ff0", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -4139,8 +4139,8 @@ "databricks": "58b79aaeb9587eafe21bc119", "duckdb": "58b79aaeb9587eafe21bc119", "generic": "58b79aaeb9587eafe21bc119", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "58b79aaeb9587eafe21bc119", +"motherduck": "58b79aaeb9587eafe21bc119", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "58b79aaeb9587eafe21bc119", "postgresql": "58b79aaeb9587eafe21bc119", "snowflake": "58b79aaeb9587eafe21bc119", @@ -4152,14 +4152,14 @@ { "DuckDB": "776e4bf23c8ef10ffaceade2", "None": "776e4bf23c8ef10ffaceade2", -"bigquery": "776e4bf23c8ef10ffaceade2", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "776e4bf23c8ef10ffaceade2", "duckdb": "776e4bf23c8ef10ffaceade2", "generic": "776e4bf23c8ef10ffaceade2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "776e4bf23c8ef10ffaceade2", -"postgres": "776e4bf23c8ef10ffaceade2", -"postgresql": "776e4bf23c8ef10ffaceade2", +"motherduck": "776e4bf23c8ef10ffaceade2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5d06b10843e3e6487fb9906a", +"postgresql": "5d06b10843e3e6487fb9906a", "snowflake": "776e4bf23c8ef10ffaceade2", "tsql": "776e4bf23c8ef10ffaceade2" } @@ -4173,8 +4173,8 @@ "databricks": "73d31c6e78cdc3b595b9c4e9", "duckdb": "73d31c6e78cdc3b595b9c4e9", "generic": "73d31c6e78cdc3b595b9c4e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73d31c6e78cdc3b595b9c4e9", +"motherduck": "73d31c6e78cdc3b595b9c4e9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "73d31c6e78cdc3b595b9c4e9", "postgresql": "73d31c6e78cdc3b595b9c4e9", "snowflake": "73d31c6e78cdc3b595b9c4e9", @@ -4190,8 +4190,8 @@ "databricks": "57922064a7dc546cbb50e42b", "duckdb": "57922064a7dc546cbb50e42b", "generic": "57922064a7dc546cbb50e42b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "57922064a7dc546cbb50e42b", +"motherduck": "57922064a7dc546cbb50e42b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "57922064a7dc546cbb50e42b", "postgresql": "57922064a7dc546cbb50e42b", "snowflake": "57922064a7dc546cbb50e42b", @@ -4203,14 +4203,14 @@ { "DuckDB": "e408f2d8251e1675179187e6", "None": "e408f2d8251e1675179187e6", -"bigquery": "e408f2d8251e1675179187e6", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "e408f2d8251e1675179187e6", "duckdb": "e408f2d8251e1675179187e6", "generic": "e408f2d8251e1675179187e6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e408f2d8251e1675179187e6", -"postgres": "e408f2d8251e1675179187e6", -"postgresql": "e408f2d8251e1675179187e6", +"motherduck": "e408f2d8251e1675179187e6", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "04bfa329b4dc3b5c43ad2560", +"postgresql": "04bfa329b4dc3b5c43ad2560", "snowflake": "e408f2d8251e1675179187e6", "tsql": "e408f2d8251e1675179187e6" } @@ -4220,14 +4220,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -4241,8 +4241,8 @@ "databricks": "5c528c7b4329aeb692ec6e94", "duckdb": "5c528c7b4329aeb692ec6e94", "generic": "5c528c7b4329aeb692ec6e94", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c528c7b4329aeb692ec6e94", +"motherduck": "5c528c7b4329aeb692ec6e94", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5c528c7b4329aeb692ec6e94", "postgresql": "5c528c7b4329aeb692ec6e94", "snowflake": "5c528c7b4329aeb692ec6e94", @@ -4258,8 +4258,8 @@ "databricks": "96ecb0bd0c27167bf4e31a08", "duckdb": "96ecb0bd0c27167bf4e31a08", "generic": "96ecb0bd0c27167bf4e31a08", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "96ecb0bd0c27167bf4e31a08", +"motherduck": "96ecb0bd0c27167bf4e31a08", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "96ecb0bd0c27167bf4e31a08", "postgresql": "96ecb0bd0c27167bf4e31a08", "snowflake": "96ecb0bd0c27167bf4e31a08", @@ -4275,8 +4275,8 @@ "databricks": "b46dfa976d5ba04f95bea32b", "duckdb": "b46dfa976d5ba04f95bea32b", "generic": "b46dfa976d5ba04f95bea32b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b46dfa976d5ba04f95bea32b", +"motherduck": "b46dfa976d5ba04f95bea32b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "34dcdfe3e3afe6140e1353e0", "postgresql": "34dcdfe3e3afe6140e1353e0", "snowflake": "b46dfa976d5ba04f95bea32b", @@ -4287,51 +4287,51 @@ "type", { "DuckDB": "f8262a8fca64e4491f151610", -"None": "dee6957f9182718819d5f721", -"bigquery": "c9c3ab06d6a47f6501ca2f3f", -"databricks": "47f8ea982c36ab449140ac7a", +"None": "fbcb21692163c35ec690c1a4", +"bigquery": "c74425c5ce650ac69c83ca5b", +"databricks": "fbcb21692163c35ec690c1a4", "duckdb": "f8262a8fca64e4491f151610", -"generic": "dee6957f9182718819d5f721", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "dee6957f9182718819d5f721", -"postgres": "5bc5cf0052fdc17435b19fc2", -"postgresql": "5bc5cf0052fdc17435b19fc2", +"generic": "fbcb21692163c35ec690c1a4", +"motherduck": "f8262a8fca64e4491f151610", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "fbcb21692163c35ec690c1a4", +"postgresql": "fbcb21692163c35ec690c1a4", "snowflake": "f8262a8fca64e4491f151610", -"tsql": "dee6957f9182718819d5f721" +"tsql": "fbcb21692163c35ec690c1a4" } ], [ "type", { "DuckDB": "b694aa93969368381cb9d9bd", -"None": "b694aa93969368381cb9d9bd", -"bigquery": "df6620c838173adb34d41a29", -"databricks": "b694aa93969368381cb9d9bd", +"None": "fdd892c7bbc36567f9619175", +"bigquery": "3c0719ca5c83e0a20d0b0b42", +"databricks": "fdd892c7bbc36567f9619175", "duckdb": "b694aa93969368381cb9d9bd", -"generic": "b694aa93969368381cb9d9bd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b694aa93969368381cb9d9bd", +"generic": "fdd892c7bbc36567f9619175", +"motherduck": "b694aa93969368381cb9d9bd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b694aa93969368381cb9d9bd", "postgresql": "b694aa93969368381cb9d9bd", "snowflake": "58d5f123164e58c358315897", -"tsql": "b694aa93969368381cb9d9bd" +"tsql": "fdd892c7bbc36567f9619175" } ], [ "type", { "DuckDB": "c50a316d091c821866e4bfba", -"None": "c50a316d091c821866e4bfba", -"bigquery": "c50a316d091c821866e4bfba", -"databricks": "c50a316d091c821866e4bfba", +"None": "e6ffdece2977be55da73b59a", +"bigquery": "e6ffdece2977be55da73b59a", +"databricks": "e6ffdece2977be55da73b59a", "duckdb": "c50a316d091c821866e4bfba", -"generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"generic": "e6ffdece2977be55da73b59a", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", -"tsql": "c50a316d091c821866e4bfba" +"tsql": "e6ffdece2977be55da73b59a" } ], [ @@ -4343,8 +4343,8 @@ "databricks": "a49cf160806465e17f3bb015", "duckdb": "2a0e1cbf59d282b31816d003", "generic": "2a0e1cbf59d282b31816d003", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a49cf160806465e17f3bb015", +"motherduck": "2a0e1cbf59d282b31816d003", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2a0e1cbf59d282b31816d003", "postgresql": "2a0e1cbf59d282b31816d003", "snowflake": "8cdd1c724939d35c854480a1", @@ -4360,8 +4360,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -4373,12 +4373,12 @@ { "DuckDB": "401e8475dd39d667a86332fd", "None": "401e8475dd39d667a86332fd", -"bigquery": "122a82cc999a6e522d790b87", +"bigquery": "0439c1de159d15c43453a07b", "databricks": "e33f1ebea03ff1cb2c6e78c4", "duckdb": "401e8475dd39d667a86332fd", "generic": "401e8475dd39d667a86332fd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "401e8475dd39d667a86332fd", +"motherduck": "401e8475dd39d667a86332fd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "401e8475dd39d667a86332fd", "postgresql": "401e8475dd39d667a86332fd", "snowflake": "5f8d9b6f22793dc26cf2fd62", @@ -4394,8 +4394,8 @@ "databricks": "5aa51d84ac5e6c7a9306f348", "duckdb": "5aa51d84ac5e6c7a9306f348", "generic": "5aa51d84ac5e6c7a9306f348", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5aa51d84ac5e6c7a9306f348", +"motherduck": "5aa51d84ac5e6c7a9306f348", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5aa51d84ac5e6c7a9306f348", "postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "5aa51d84ac5e6c7a9306f348", @@ -4411,8 +4411,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -4428,8 +4428,8 @@ "databricks": "87fed6659d6324c5ef0c6ee2", "duckdb": "c344d36a6751b773df74ee3c", "generic": "87fed6659d6324c5ef0c6ee2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "87fed6659d6324c5ef0c6ee2", +"motherduck": "c344d36a6751b773df74ee3c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "87fed6659d6324c5ef0c6ee2", "postgresql": "87fed6659d6324c5ef0c6ee2", "snowflake": "87fed6659d6324c5ef0c6ee2", @@ -4441,14 +4441,14 @@ { "DuckDB": "de89632e277dbc8c97115419", "None": "de89632e277dbc8c97115419", -"bigquery": "de89632e277dbc8c97115419", +"bigquery": "5abf4ec799a2ec32fb10da7e", "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -4457,17 +4457,17 @@ "type", { "DuckDB": "3147a9e06daa6de4a4df5abc", -"None": "3147a9e06daa6de4a4df5abc", -"bigquery": "f276e907770196606577c932", -"databricks": "3147a9e06daa6de4a4df5abc", +"None": "da0625706f12b764a6912278", +"bigquery": "b0477b36767a62145aa9158c", +"databricks": "da0625706f12b764a6912278", "duckdb": "3147a9e06daa6de4a4df5abc", -"generic": "3147a9e06daa6de4a4df5abc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3147a9e06daa6de4a4df5abc", +"generic": "da0625706f12b764a6912278", +"motherduck": "3147a9e06daa6de4a4df5abc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3147a9e06daa6de4a4df5abc", "postgresql": "3147a9e06daa6de4a4df5abc", "snowflake": "67b5874a2c569226c490211f", -"tsql": "3147a9e06daa6de4a4df5abc" +"tsql": "da0625706f12b764a6912278" } ], [ @@ -4479,8 +4479,8 @@ "databricks": "b2598e21f41a4625fa001e55", "duckdb": "b2598e21f41a4625fa001e55", "generic": "b2598e21f41a4625fa001e55", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b2598e21f41a4625fa001e55", +"motherduck": "b2598e21f41a4625fa001e55", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b2598e21f41a4625fa001e55", "postgresql": "b2598e21f41a4625fa001e55", "snowflake": "b2598e21f41a4625fa001e55", @@ -4496,8 +4496,8 @@ "databricks": "e62af34c2d31bc9ab880629e", "duckdb": "8a7aa7fa75696327320e0add", "generic": "8a7aa7fa75696327320e0add", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e62af34c2d31bc9ab880629e", +"motherduck": "8a7aa7fa75696327320e0add", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8a7aa7fa75696327320e0add", "postgresql": "8a7aa7fa75696327320e0add", "snowflake": "8a7aa7fa75696327320e0add", @@ -4513,8 +4513,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -4526,12 +4526,12 @@ { "DuckDB": "aae2b1fe6f2d9807ecde412b", "None": "aae2b1fe6f2d9807ecde412b", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "aae2b1fe6f2d9807ecde412b", "duckdb": "aae2b1fe6f2d9807ecde412b", "generic": "aae2b1fe6f2d9807ecde412b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aae2b1fe6f2d9807ecde412b", +"motherduck": "aae2b1fe6f2d9807ecde412b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "aae2b1fe6f2d9807ecde412b", "postgresql": "aae2b1fe6f2d9807ecde412b", "snowflake": "aae2b1fe6f2d9807ecde412b", @@ -4547,8 +4547,8 @@ "databricks": "f7fca17b74cc50ae3de8c826", "duckdb": "f7fca17b74cc50ae3de8c826", "generic": "f7fca17b74cc50ae3de8c826", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f7fca17b74cc50ae3de8c826", +"motherduck": "f7fca17b74cc50ae3de8c826", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f7fca17b74cc50ae3de8c826", "postgresql": "f7fca17b74cc50ae3de8c826", "snowflake": "55155766823b6a3a5e882fc2", @@ -4560,14 +4560,14 @@ { "DuckDB": "95050a5e73c2bff179a785b7", "None": "95050a5e73c2bff179a785b7", -"bigquery": "95050a5e73c2bff179a785b7", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "95050a5e73c2bff179a785b7", "duckdb": "95050a5e73c2bff179a785b7", "generic": "95050a5e73c2bff179a785b7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "95050a5e73c2bff179a785b7", -"postgres": "95050a5e73c2bff179a785b7", -"postgresql": "95050a5e73c2bff179a785b7", +"motherduck": "95050a5e73c2bff179a785b7", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e197cb69fc5e5754a25d4038", +"postgresql": "e197cb69fc5e5754a25d4038", "snowflake": "95050a5e73c2bff179a785b7", "tsql": "95050a5e73c2bff179a785b7" } @@ -4581,8 +4581,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -4594,14 +4594,14 @@ { "DuckDB": "e46d4be44ab9e500e9190d26", "None": "e46d4be44ab9e500e9190d26", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -4610,17 +4610,17 @@ "type", { "DuckDB": "314ed506f24e92300a425780", -"None": "314ed506f24e92300a425780", -"bigquery": "314ed506f24e92300a425780", -"databricks": "314ed506f24e92300a425780", +"None": "9a66317fb8d040bf991502c0", +"bigquery": "9bafb08d41fd1c208b5deca4", +"databricks": "9a66317fb8d040bf991502c0", "duckdb": "314ed506f24e92300a425780", -"generic": "314ed506f24e92300a425780", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "314ed506f24e92300a425780", +"generic": "9a66317fb8d040bf991502c0", +"motherduck": "314ed506f24e92300a425780", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "314ed506f24e92300a425780", "postgresql": "314ed506f24e92300a425780", "snowflake": "314ed506f24e92300a425780", -"tsql": "314ed506f24e92300a425780" +"tsql": "9a66317fb8d040bf991502c0" } ], [ @@ -4632,8 +4632,8 @@ "databricks": "f4c43a87a78970bca1f88b09", "duckdb": "f4c43a87a78970bca1f88b09", "generic": "f4c43a87a78970bca1f88b09", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f4c43a87a78970bca1f88b09", +"motherduck": "f4c43a87a78970bca1f88b09", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f4c43a87a78970bca1f88b09", "postgresql": "f4c43a87a78970bca1f88b09", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -4649,10 +4649,10 @@ "databricks": "f8d53ecf4ba59d519bb15d38", "duckdb": "f8d53ecf4ba59d519bb15d38", "generic": "f8d53ecf4ba59d519bb15d38", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f8d53ecf4ba59d519bb15d38", -"postgres": "f8d53ecf4ba59d519bb15d38", -"postgresql": "f8d53ecf4ba59d519bb15d38", +"motherduck": "f8d53ecf4ba59d519bb15d38", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "61d79925ac143bbc1051c8fa", +"postgresql": "61d79925ac143bbc1051c8fa", "snowflake": "f8d53ecf4ba59d519bb15d38", "tsql": "f8d53ecf4ba59d519bb15d38" } @@ -4666,8 +4666,8 @@ "databricks": "d6e37cd37419bfb26e09b080", "duckdb": "d6e37cd37419bfb26e09b080", "generic": "d6e37cd37419bfb26e09b080", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d6e37cd37419bfb26e09b080", +"motherduck": "d6e37cd37419bfb26e09b080", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d6e37cd37419bfb26e09b080", "postgresql": "d6e37cd37419bfb26e09b080", "snowflake": "d6e37cd37419bfb26e09b080", @@ -4683,8 +4683,8 @@ "databricks": "94f6df33eccb97170eccb01b", "duckdb": "94f6df33eccb97170eccb01b", "generic": "94f6df33eccb97170eccb01b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "94f6df33eccb97170eccb01b", +"motherduck": "94f6df33eccb97170eccb01b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "94f6df33eccb97170eccb01b", "postgresql": "94f6df33eccb97170eccb01b", "snowflake": "94f6df33eccb97170eccb01b", @@ -4700,8 +4700,8 @@ "databricks": "8c0b6775b8364e21d86e6e85", "duckdb": "8c0b6775b8364e21d86e6e85", "generic": "8c0b6775b8364e21d86e6e85", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8c0b6775b8364e21d86e6e85", +"motherduck": "8c0b6775b8364e21d86e6e85", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8c0b6775b8364e21d86e6e85", "postgresql": "8c0b6775b8364e21d86e6e85", "snowflake": "8c0b6775b8364e21d86e6e85", @@ -4717,8 +4717,8 @@ "databricks": "2038903a8b2174e3b3525f45", "duckdb": "2038903a8b2174e3b3525f45", "generic": "2038903a8b2174e3b3525f45", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2038903a8b2174e3b3525f45", +"motherduck": "2038903a8b2174e3b3525f45", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2038903a8b2174e3b3525f45", "postgresql": "2038903a8b2174e3b3525f45", "snowflake": "2038903a8b2174e3b3525f45", @@ -4728,18 +4728,18 @@ [ "type", { -"DuckDB": "57a219193ee01aa40a7a339d", -"None": "1cff449f8adc98f1234ffeec", -"bigquery": "c49aa38b33ba6204f42571c8", -"databricks": "1cff449f8adc98f1234ffeec", -"duckdb": "57a219193ee01aa40a7a339d", -"generic": "1cff449f8adc98f1234ffeec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1cff449f8adc98f1234ffeec", -"postgres": "1cff449f8adc98f1234ffeec", -"postgresql": "1cff449f8adc98f1234ffeec", +"DuckDB": "bfb659237d70eae4d07a6d10", +"None": "009acb58d411c47680971462", +"bigquery": "c74425c5ce650ac69c83ca5b", +"databricks": "009acb58d411c47680971462", +"duckdb": "bfb659237d70eae4d07a6d10", +"generic": "009acb58d411c47680971462", +"motherduck": "bfb659237d70eae4d07a6d10", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "bfb659237d70eae4d07a6d10", +"postgresql": "bfb659237d70eae4d07a6d10", "snowflake": "bfb659237d70eae4d07a6d10", -"tsql": "1cff449f8adc98f1234ffeec" +"tsql": "009acb58d411c47680971462" } ], [ @@ -4751,8 +4751,8 @@ "databricks": "e0faa139ea3b65b1356bd333", "duckdb": "e0faa139ea3b65b1356bd333", "generic": "e0faa139ea3b65b1356bd333", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e0faa139ea3b65b1356bd333", +"motherduck": "e0faa139ea3b65b1356bd333", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e0faa139ea3b65b1356bd333", "postgresql": "e0faa139ea3b65b1356bd333", "snowflake": "e0faa139ea3b65b1356bd333", @@ -4768,10 +4768,10 @@ "databricks": "a3acd7ba35e81a800f967bd3", "duckdb": "42d4a23d9a52e79d0c3458d3", "generic": "a3acd7ba35e81a800f967bd3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a3acd7ba35e81a800f967bd3", -"postgres": "a3acd7ba35e81a800f967bd3", -"postgresql": "a3acd7ba35e81a800f967bd3", +"motherduck": "42d4a23d9a52e79d0c3458d3", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "42d4a23d9a52e79d0c3458d3", +"postgresql": "42d4a23d9a52e79d0c3458d3", "snowflake": "a3acd7ba35e81a800f967bd3", "tsql": "a3acd7ba35e81a800f967bd3" } @@ -4785,8 +4785,8 @@ "databricks": "2795ccedbfd3fa0bed5fdfcd", "duckdb": "2795ccedbfd3fa0bed5fdfcd", "generic": "2795ccedbfd3fa0bed5fdfcd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2795ccedbfd3fa0bed5fdfcd", +"motherduck": "2795ccedbfd3fa0bed5fdfcd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2795ccedbfd3fa0bed5fdfcd", "postgresql": "2795ccedbfd3fa0bed5fdfcd", "snowflake": "2795ccedbfd3fa0bed5fdfcd", @@ -4802,10 +4802,10 @@ "databricks": "de89632e277dbc8c97115419", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -4819,8 +4819,8 @@ "databricks": "4a014523269fae92f3ad421a", "duckdb": "4a014523269fae92f3ad421a", "generic": "4a014523269fae92f3ad421a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4a014523269fae92f3ad421a", +"motherduck": "4a014523269fae92f3ad421a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4a014523269fae92f3ad421a", "postgresql": "4a014523269fae92f3ad421a", "snowflake": "4a014523269fae92f3ad421a", @@ -4836,8 +4836,8 @@ "databricks": "684469f7d4198e43e63072ce", "duckdb": "684469f7d4198e43e63072ce", "generic": "684469f7d4198e43e63072ce", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "684469f7d4198e43e63072ce", +"motherduck": "684469f7d4198e43e63072ce", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "684469f7d4198e43e63072ce", "postgresql": "684469f7d4198e43e63072ce", "snowflake": "684469f7d4198e43e63072ce", @@ -4853,8 +4853,8 @@ "databricks": "e998cd8f0f74af0526b75ff0", "duckdb": "e998cd8f0f74af0526b75ff0", "generic": "e998cd8f0f74af0526b75ff0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e998cd8f0f74af0526b75ff0", +"motherduck": "e998cd8f0f74af0526b75ff0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e998cd8f0f74af0526b75ff0", "postgresql": "e998cd8f0f74af0526b75ff0", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -4870,8 +4870,8 @@ "databricks": "1a804f317a3e9a0016925b04", "duckdb": "110327dc45eac0e8d54a96dc", "generic": "110327dc45eac0e8d54a96dc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1a804f317a3e9a0016925b04", +"motherduck": "110327dc45eac0e8d54a96dc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "110327dc45eac0e8d54a96dc", "postgresql": "110327dc45eac0e8d54a96dc", "snowflake": "110327dc45eac0e8d54a96dc", @@ -4882,34 +4882,34 @@ "type", { "DuckDB": "5abf4ec799a2ec32fb10da7e", -"None": "5abf4ec799a2ec32fb10da7e", -"bigquery": "5abf4ec799a2ec32fb10da7e", -"databricks": "5abf4ec799a2ec32fb10da7e", +"None": "4b356542044f1267fcfc487a", +"bigquery": "a5656d70e208254d1d3e9b4f", +"databricks": "4b356542044f1267fcfc487a", "duckdb": "5abf4ec799a2ec32fb10da7e", -"generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", -"postgres": "5abf4ec799a2ec32fb10da7e", -"postgresql": "5abf4ec799a2ec32fb10da7e", +"generic": "4b356542044f1267fcfc487a", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a5656d70e208254d1d3e9b4f", +"postgresql": "a5656d70e208254d1d3e9b4f", "snowflake": "a5656d70e208254d1d3e9b4f", -"tsql": "5abf4ec799a2ec32fb10da7e" +"tsql": "4b356542044f1267fcfc487a" } ], [ "type", { "DuckDB": "f7fca17b74cc50ae3de8c826", -"None": "f7fca17b74cc50ae3de8c826", -"bigquery": "f7fca17b74cc50ae3de8c826", -"databricks": "f7fca17b74cc50ae3de8c826", +"None": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", +"databricks": "d2c97d221599d038d9875873", "duckdb": "f7fca17b74cc50ae3de8c826", -"generic": "f7fca17b74cc50ae3de8c826", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f7fca17b74cc50ae3de8c826", -"postgres": "f7fca17b74cc50ae3de8c826", -"postgresql": "f7fca17b74cc50ae3de8c826", +"generic": "d2c97d221599d038d9875873", +"motherduck": "f7fca17b74cc50ae3de8c826", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "55155766823b6a3a5e882fc2", -"tsql": "f7fca17b74cc50ae3de8c826" +"tsql": "d2c97d221599d038d9875873" } ], [ @@ -4917,12 +4917,12 @@ { "DuckDB": "4d02ddd0ab80d0d46bf48a5f", "None": "4d02ddd0ab80d0d46bf48a5f", -"bigquery": "4d02ddd0ab80d0d46bf48a5f", +"bigquery": "3d7437d0bdf5ed3aa20531f2", "databricks": "4d02ddd0ab80d0d46bf48a5f", "duckdb": "4d02ddd0ab80d0d46bf48a5f", "generic": "4d02ddd0ab80d0d46bf48a5f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4d02ddd0ab80d0d46bf48a5f", +"motherduck": "4d02ddd0ab80d0d46bf48a5f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4d02ddd0ab80d0d46bf48a5f", "postgresql": "4d02ddd0ab80d0d46bf48a5f", "snowflake": "4d02ddd0ab80d0d46bf48a5f", @@ -4934,14 +4934,14 @@ { "DuckDB": "18db5afe2c1e80d1ee652b54", "None": "18db5afe2c1e80d1ee652b54", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "18db5afe2c1e80d1ee652b54", "duckdb": "18db5afe2c1e80d1ee652b54", "generic": "18db5afe2c1e80d1ee652b54", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "18db5afe2c1e80d1ee652b54", -"postgres": "18db5afe2c1e80d1ee652b54", -"postgresql": "18db5afe2c1e80d1ee652b54", +"motherduck": "18db5afe2c1e80d1ee652b54", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "47d64a5994d42a2b577166ea", +"postgresql": "47d64a5994d42a2b577166ea", "snowflake": "18db5afe2c1e80d1ee652b54", "tsql": "18db5afe2c1e80d1ee652b54" } @@ -4955,8 +4955,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -4972,8 +4972,8 @@ "databricks": "d5af64f521c46f0f5c6d1ad0", "duckdb": "d5af64f521c46f0f5c6d1ad0", "generic": "d5af64f521c46f0f5c6d1ad0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d5af64f521c46f0f5c6d1ad0", +"motherduck": "d5af64f521c46f0f5c6d1ad0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d5af64f521c46f0f5c6d1ad0", "postgresql": "d5af64f521c46f0f5c6d1ad0", "snowflake": "d5af64f521c46f0f5c6d1ad0", @@ -4989,8 +4989,8 @@ "databricks": "6e4f718d80b641c205a88635", "duckdb": "38e28682c0f47e13e642ab1c", "generic": "38e28682c0f47e13e642ab1c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "25f9faed41d5d23ca3fa8175", +"motherduck": "38e28682c0f47e13e642ab1c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "38e28682c0f47e13e642ab1c", "postgresql": "38e28682c0f47e13e642ab1c", "snowflake": "41cf14d12db9a99ffd9a4514", @@ -5006,8 +5006,8 @@ "databricks": "558da38ec4d9d5d6c72f60cf", "duckdb": "0a735e1254c48785122ee5a3", "generic": "558da38ec4d9d5d6c72f60cf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "558da38ec4d9d5d6c72f60cf", +"motherduck": "0a735e1254c48785122ee5a3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "558da38ec4d9d5d6c72f60cf", "postgresql": "558da38ec4d9d5d6c72f60cf", "snowflake": "558da38ec4d9d5d6c72f60cf", @@ -5023,8 +5023,8 @@ "databricks": "c16b4b4f382469fb186a9022", "duckdb": "c16b4b4f382469fb186a9022", "generic": "c16b4b4f382469fb186a9022", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c16b4b4f382469fb186a9022", +"motherduck": "c16b4b4f382469fb186a9022", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c16b4b4f382469fb186a9022", "postgresql": "c16b4b4f382469fb186a9022", "snowflake": "c16b4b4f382469fb186a9022", @@ -5036,14 +5036,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -5057,8 +5057,8 @@ "databricks": "9e4a50a8aab648a9737f7d0c", "duckdb": "9e4a50a8aab648a9737f7d0c", "generic": "9e4a50a8aab648a9737f7d0c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9e4a50a8aab648a9737f7d0c", +"motherduck": "9e4a50a8aab648a9737f7d0c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "36d29258901a4d8c296baa68", "postgresql": "36d29258901a4d8c296baa68", "snowflake": "9e4a50a8aab648a9737f7d0c", @@ -5074,8 +5074,8 @@ "databricks": "f43dac38f34a1c0618a3f812", "duckdb": "f43dac38f34a1c0618a3f812", "generic": "f43dac38f34a1c0618a3f812", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f43dac38f34a1c0618a3f812", +"motherduck": "f43dac38f34a1c0618a3f812", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f43dac38f34a1c0618a3f812", "postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "f43dac38f34a1c0618a3f812", @@ -5091,8 +5091,8 @@ "databricks": "e8605878c6fffc044556a858", "duckdb": "e8605878c6fffc044556a858", "generic": "e8605878c6fffc044556a858", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e8605878c6fffc044556a858", +"motherduck": "e8605878c6fffc044556a858", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8605878c6fffc044556a858", "postgresql": "e8605878c6fffc044556a858", "snowflake": "e8605878c6fffc044556a858", @@ -5108,8 +5108,8 @@ "databricks": "e8ef65ce7616ceeafffe41f6", "duckdb": "e8ef65ce7616ceeafffe41f6", "generic": "e8ef65ce7616ceeafffe41f6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e8ef65ce7616ceeafffe41f6", +"motherduck": "e8ef65ce7616ceeafffe41f6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8ef65ce7616ceeafffe41f6", "postgresql": "e8ef65ce7616ceeafffe41f6", "snowflake": "e8ef65ce7616ceeafffe41f6", @@ -5125,8 +5125,8 @@ "databricks": "77ffdb80029bd6e2cca768ad", "duckdb": "77ffdb80029bd6e2cca768ad", "generic": "77ffdb80029bd6e2cca768ad", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "77ffdb80029bd6e2cca768ad", +"motherduck": "77ffdb80029bd6e2cca768ad", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "77ffdb80029bd6e2cca768ad", "postgresql": "77ffdb80029bd6e2cca768ad", "snowflake": "77ffdb80029bd6e2cca768ad", @@ -5142,8 +5142,8 @@ "databricks": "c4346d0257336219f1d26890", "duckdb": "c4346d0257336219f1d26890", "generic": "c4346d0257336219f1d26890", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c4346d0257336219f1d26890", +"motherduck": "c4346d0257336219f1d26890", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c4346d0257336219f1d26890", "postgresql": "c4346d0257336219f1d26890", "snowflake": "4e24a80b20b9dee0cbbfac17", @@ -5154,17 +5154,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -5172,12 +5172,12 @@ { "DuckDB": "3e611643f0beab4953c4e09b", "None": "3e611643f0beab4953c4e09b", -"bigquery": "2a0918be53051fe629d9ff8f", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "3e611643f0beab4953c4e09b", "duckdb": "3e611643f0beab4953c4e09b", "generic": "3e611643f0beab4953c4e09b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3e611643f0beab4953c4e09b", +"motherduck": "3e611643f0beab4953c4e09b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3e611643f0beab4953c4e09b", "postgresql": "3e611643f0beab4953c4e09b", "snowflake": "3e611643f0beab4953c4e09b", @@ -5189,14 +5189,14 @@ { "DuckDB": "776e4bf23c8ef10ffaceade2", "None": "776e4bf23c8ef10ffaceade2", -"bigquery": "776e4bf23c8ef10ffaceade2", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "776e4bf23c8ef10ffaceade2", "duckdb": "776e4bf23c8ef10ffaceade2", "generic": "776e4bf23c8ef10ffaceade2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "776e4bf23c8ef10ffaceade2", -"postgres": "776e4bf23c8ef10ffaceade2", -"postgresql": "776e4bf23c8ef10ffaceade2", +"motherduck": "776e4bf23c8ef10ffaceade2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5d06b10843e3e6487fb9906a", +"postgresql": "5d06b10843e3e6487fb9906a", "snowflake": "776e4bf23c8ef10ffaceade2", "tsql": "776e4bf23c8ef10ffaceade2" } @@ -5210,8 +5210,8 @@ "databricks": "3915f3f73328f0838497b2d5", "duckdb": "3915f3f73328f0838497b2d5", "generic": "3915f3f73328f0838497b2d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3915f3f73328f0838497b2d5", +"motherduck": "3915f3f73328f0838497b2d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3915f3f73328f0838497b2d5", "postgresql": "3915f3f73328f0838497b2d5", "snowflake": "f43dac38f34a1c0618a3f812", @@ -5227,8 +5227,8 @@ "databricks": "5abf4ec799a2ec32fb10da7e", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5abf4ec799a2ec32fb10da7e", "postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -5244,8 +5244,8 @@ "databricks": "eed0645c1e86fa1a6e35ccaa", "duckdb": "eed0645c1e86fa1a6e35ccaa", "generic": "eed0645c1e86fa1a6e35ccaa", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "eed0645c1e86fa1a6e35ccaa", +"motherduck": "eed0645c1e86fa1a6e35ccaa", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "eed0645c1e86fa1a6e35ccaa", "postgresql": "eed0645c1e86fa1a6e35ccaa", "snowflake": "97a20344d811fb77c7690863", @@ -5256,17 +5256,17 @@ "type", { "DuckDB": "c50a316d091c821866e4bfba", -"None": "c50a316d091c821866e4bfba", -"bigquery": "c50a316d091c821866e4bfba", -"databricks": "c50a316d091c821866e4bfba", +"None": "e6ffdece2977be55da73b59a", +"bigquery": "e6ffdece2977be55da73b59a", +"databricks": "e6ffdece2977be55da73b59a", "duckdb": "c50a316d091c821866e4bfba", -"generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"generic": "e6ffdece2977be55da73b59a", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", -"tsql": "c50a316d091c821866e4bfba" +"tsql": "e6ffdece2977be55da73b59a" } ], [ @@ -5278,8 +5278,8 @@ "databricks": "962ea05bab624c1f8c259a65", "duckdb": "962ea05bab624c1f8c259a65", "generic": "962ea05bab624c1f8c259a65", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "962ea05bab624c1f8c259a65", +"motherduck": "962ea05bab624c1f8c259a65", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "962ea05bab624c1f8c259a65", "postgresql": "962ea05bab624c1f8c259a65", "snowflake": "962ea05bab624c1f8c259a65", @@ -5295,8 +5295,8 @@ "databricks": "d638c2852078bf3facb9dc9e", "duckdb": "207acc46dcc150502155f4a3", "generic": "d638c2852078bf3facb9dc9e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "207acc46dcc150502155f4a3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6c49aec265f259dd95b5310e", "postgresql": "6c49aec265f259dd95b5310e", "snowflake": "ef2c05747b795f92c0b523ee", @@ -5312,10 +5312,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "9d006c5299feb04426ce31ac", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "9d006c5299feb04426ce31ac", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -5329,8 +5329,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -5346,8 +5346,8 @@ "databricks": "6a726882dbf443e39240fc33", "duckdb": "6a726882dbf443e39240fc33", "generic": "6a726882dbf443e39240fc33", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6a726882dbf443e39240fc33", +"motherduck": "6a726882dbf443e39240fc33", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6a726882dbf443e39240fc33", "postgresql": "6a726882dbf443e39240fc33", "snowflake": "6a726882dbf443e39240fc33", @@ -5363,8 +5363,8 @@ "databricks": "c4860fb394ecca5e4515f1c9", "duckdb": "c4860fb394ecca5e4515f1c9", "generic": "c4860fb394ecca5e4515f1c9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c4860fb394ecca5e4515f1c9", +"motherduck": "c4860fb394ecca5e4515f1c9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c4860fb394ecca5e4515f1c9", "postgresql": "c4860fb394ecca5e4515f1c9", "snowflake": "c4860fb394ecca5e4515f1c9", @@ -5375,17 +5375,17 @@ "type", { "DuckDB": "363159f251e264604338e690", -"None": "363159f251e264604338e690", -"bigquery": "363159f251e264604338e690", -"databricks": "363159f251e264604338e690", +"None": "9a63ad6168418af23d9b6fd1", +"bigquery": "8b8d5f75ba6dec68b4cebc6b", +"databricks": "9a63ad6168418af23d9b6fd1", "duckdb": "363159f251e264604338e690", -"generic": "363159f251e264604338e690", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "363159f251e264604338e690", -"postgres": "363159f251e264604338e690", -"postgresql": "363159f251e264604338e690", +"generic": "9a63ad6168418af23d9b6fd1", +"motherduck": "363159f251e264604338e690", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f276e907770196606577c932", +"postgresql": "f276e907770196606577c932", "snowflake": "363159f251e264604338e690", -"tsql": "363159f251e264604338e690" +"tsql": "9a63ad6168418af23d9b6fd1" } ], [ @@ -5397,8 +5397,8 @@ "databricks": "fe1d4d12e4b12d78f4ce545d", "duckdb": "fe1d4d12e4b12d78f4ce545d", "generic": "fe1d4d12e4b12d78f4ce545d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe1d4d12e4b12d78f4ce545d", +"motherduck": "fe1d4d12e4b12d78f4ce545d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fe1d4d12e4b12d78f4ce545d", "postgresql": "fe1d4d12e4b12d78f4ce545d", "snowflake": "fe1d4d12e4b12d78f4ce545d", @@ -5414,10 +5414,10 @@ "databricks": "5829c1427d562e21c1ed4dfe", "duckdb": "5829c1427d562e21c1ed4dfe", "generic": "5829c1427d562e21c1ed4dfe", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5829c1427d562e21c1ed4dfe", -"postgres": "5829c1427d562e21c1ed4dfe", -"postgresql": "5829c1427d562e21c1ed4dfe", +"motherduck": "5829c1427d562e21c1ed4dfe", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "348b6977d03b636ecd10e63d", +"postgresql": "348b6977d03b636ecd10e63d", "snowflake": "5829c1427d562e21c1ed4dfe", "tsql": "5829c1427d562e21c1ed4dfe" } @@ -5431,8 +5431,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -5443,15 +5443,15 @@ "type", { "DuckDB": "e3ba57c3380e7ca53675e905", -"None": "85dad253f82f475892a7b35b", -"bigquery": "85dad253f82f475892a7b35b", -"databricks": "534433bc99c8d49f592ba435", +"None": "87673dc143bcd33d8688dc34", +"bigquery": "87673dc143bcd33d8688dc34", +"databricks": "87673dc143bcd33d8688dc34", "duckdb": "e3ba57c3380e7ca53675e905", -"generic": "85dad253f82f475892a7b35b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3dd1a4411040373d9cd82f86", -"postgres": "463c3432687f6ea95aa60355", -"postgresql": "463c3432687f6ea95aa60355", +"generic": "87673dc143bcd33d8688dc34", +"motherduck": "e3ba57c3380e7ca53675e905", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "87673dc143bcd33d8688dc34", +"postgresql": "87673dc143bcd33d8688dc34", "snowflake": "0161e12cd4d2efd1b5557348", "tsql": "87673dc143bcd33d8688dc34" } @@ -5460,17 +5460,17 @@ "type", { "DuckDB": "1fe8a2d5a41383bd8e502808", -"None": "1fe8a2d5a41383bd8e502808", +"None": "70f3d045595fbd43219efb36", "bigquery": "70f3d045595fbd43219efb36", "databricks": "70f3d045595fbd43219efb36", "duckdb": "1fe8a2d5a41383bd8e502808", -"generic": "1fe8a2d5a41383bd8e502808", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70f3d045595fbd43219efb36", -"postgres": "1fe8a2d5a41383bd8e502808", -"postgresql": "1fe8a2d5a41383bd8e502808", +"generic": "70f3d045595fbd43219efb36", +"motherduck": "1fe8a2d5a41383bd8e502808", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3c17ab67cd8c034fc4911ef2", +"postgresql": "3c17ab67cd8c034fc4911ef2", "snowflake": "1fe8a2d5a41383bd8e502808", -"tsql": "1fe8a2d5a41383bd8e502808" +"tsql": "70f3d045595fbd43219efb36" } ], [ @@ -5478,14 +5478,14 @@ { "DuckDB": "e46d4be44ab9e500e9190d26", "None": "e46d4be44ab9e500e9190d26", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -5495,12 +5495,12 @@ { "DuckDB": "1c58068460e5c94bc2f83d53", "None": "1c58068460e5c94bc2f83d53", -"bigquery": "1c58068460e5c94bc2f83d53", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "1c58068460e5c94bc2f83d53", "duckdb": "1c58068460e5c94bc2f83d53", "generic": "1c58068460e5c94bc2f83d53", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1c58068460e5c94bc2f83d53", +"motherduck": "1c58068460e5c94bc2f83d53", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1c58068460e5c94bc2f83d53", "postgresql": "1c58068460e5c94bc2f83d53", "snowflake": "1c58068460e5c94bc2f83d53", @@ -5516,8 +5516,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -5533,8 +5533,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -5550,8 +5550,8 @@ "databricks": "26e762643db86e7646e57cba", "duckdb": "26e762643db86e7646e57cba", "generic": "26e762643db86e7646e57cba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "26e762643db86e7646e57cba", +"motherduck": "26e762643db86e7646e57cba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "26e762643db86e7646e57cba", "postgresql": "26e762643db86e7646e57cba", "snowflake": "26e762643db86e7646e57cba", @@ -5567,10 +5567,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -5584,8 +5584,8 @@ "databricks": "7c0baf18eb7c47a1c83b71c3", "duckdb": "243652b8dd9a0f3ac3501ed4", "generic": "f74ed75cd28860b40bc2c2e4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "243652b8dd9a0f3ac3501ed4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "240398aee89da87a2f8274c9", "postgresql": "240398aee89da87a2f8274c9", "snowflake": "7422d281eba97abeec05a617", @@ -5601,8 +5601,8 @@ "databricks": "1bdf5908ca249b2331a0427c", "duckdb": "1bdf5908ca249b2331a0427c", "generic": "1bdf5908ca249b2331a0427c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1bdf5908ca249b2331a0427c", +"motherduck": "1bdf5908ca249b2331a0427c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1bdf5908ca249b2331a0427c", "postgresql": "1bdf5908ca249b2331a0427c", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -5618,8 +5618,8 @@ "databricks": "d725148d39793a0cbb9a6013", "duckdb": "d725148d39793a0cbb9a6013", "generic": "d725148d39793a0cbb9a6013", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d725148d39793a0cbb9a6013", +"motherduck": "d725148d39793a0cbb9a6013", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d725148d39793a0cbb9a6013", "postgresql": "d725148d39793a0cbb9a6013", "snowflake": "d725148d39793a0cbb9a6013", @@ -5635,8 +5635,8 @@ "databricks": "fe0bedb7dda0e9247a51fdee", "duckdb": "fe0bedb7dda0e9247a51fdee", "generic": "fe0bedb7dda0e9247a51fdee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe0bedb7dda0e9247a51fdee", +"motherduck": "fe0bedb7dda0e9247a51fdee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fe0bedb7dda0e9247a51fdee", "postgresql": "fe0bedb7dda0e9247a51fdee", "snowflake": "fe0bedb7dda0e9247a51fdee", @@ -5647,17 +5647,17 @@ "type", { "DuckDB": "2c44dc35fd1ef8701101802e", -"None": "2c44dc35fd1ef8701101802e", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "2c44dc35fd1ef8701101802e", +"None": "8441d00030df06ad6a5534d3", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "8441d00030df06ad6a5534d3", "duckdb": "2c44dc35fd1ef8701101802e", -"generic": "2c44dc35fd1ef8701101802e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2c44dc35fd1ef8701101802e", -"postgres": "2c44dc35fd1ef8701101802e", -"postgresql": "2c44dc35fd1ef8701101802e", +"generic": "8441d00030df06ad6a5534d3", +"motherduck": "2c44dc35fd1ef8701101802e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8441d00030df06ad6a5534d3", +"postgresql": "8441d00030df06ad6a5534d3", "snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "2c44dc35fd1ef8701101802e" +"tsql": "8441d00030df06ad6a5534d3" } ], [ @@ -5665,14 +5665,14 @@ { "DuckDB": "c4346d0257336219f1d26890", "None": "c4346d0257336219f1d26890", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "c4346d0257336219f1d26890", "duckdb": "c4346d0257336219f1d26890", "generic": "c4346d0257336219f1d26890", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c4346d0257336219f1d26890", -"postgres": "c4346d0257336219f1d26890", -"postgresql": "c4346d0257336219f1d26890", +"motherduck": "c4346d0257336219f1d26890", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "19bdd92ea0cc5fb028657510", +"postgresql": "19bdd92ea0cc5fb028657510", "snowflake": "4e24a80b20b9dee0cbbfac17", "tsql": "c4346d0257336219f1d26890" } @@ -5686,8 +5686,8 @@ "databricks": "73ed909ac0c80ba48ae6d17c", "duckdb": "73ed909ac0c80ba48ae6d17c", "generic": "73ed909ac0c80ba48ae6d17c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73ed909ac0c80ba48ae6d17c", +"motherduck": "73ed909ac0c80ba48ae6d17c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "73ed909ac0c80ba48ae6d17c", "postgresql": "73ed909ac0c80ba48ae6d17c", "snowflake": "73ed909ac0c80ba48ae6d17c", @@ -5703,8 +5703,8 @@ "databricks": "445eba49a8d5ccbd6775e1b6", "duckdb": "445eba49a8d5ccbd6775e1b6", "generic": "445eba49a8d5ccbd6775e1b6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "445eba49a8d5ccbd6775e1b6", +"motherduck": "445eba49a8d5ccbd6775e1b6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "445eba49a8d5ccbd6775e1b6", "postgresql": "445eba49a8d5ccbd6775e1b6", "snowflake": "445eba49a8d5ccbd6775e1b6", @@ -5716,14 +5716,14 @@ { "DuckDB": "097487e169d70127caa10537", "None": "097487e169d70127caa10537", -"bigquery": "097487e169d70127caa10537", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "097487e169d70127caa10537", "duckdb": "097487e169d70127caa10537", "generic": "097487e169d70127caa10537", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "097487e169d70127caa10537", -"postgres": "097487e169d70127caa10537", -"postgresql": "097487e169d70127caa10537", +"motherduck": "097487e169d70127caa10537", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ff580202d964731766475fad", +"postgresql": "ff580202d964731766475fad", "snowflake": "097487e169d70127caa10537", "tsql": "097487e169d70127caa10537" } @@ -5737,8 +5737,8 @@ "databricks": "5aa51d84ac5e6c7a9306f348", "duckdb": "5aa51d84ac5e6c7a9306f348", "generic": "5aa51d84ac5e6c7a9306f348", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5aa51d84ac5e6c7a9306f348", +"motherduck": "5aa51d84ac5e6c7a9306f348", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5aa51d84ac5e6c7a9306f348", "postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "5aa51d84ac5e6c7a9306f348", @@ -5750,12 +5750,12 @@ { "DuckDB": "383310937b9286f8d0206ea4", "None": "383310937b9286f8d0206ea4", -"bigquery": "383310937b9286f8d0206ea4", +"bigquery": "720295cb000a4e00c08800ef", "databricks": "383310937b9286f8d0206ea4", "duckdb": "383310937b9286f8d0206ea4", "generic": "383310937b9286f8d0206ea4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "383310937b9286f8d0206ea4", +"motherduck": "383310937b9286f8d0206ea4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "383310937b9286f8d0206ea4", "postgresql": "383310937b9286f8d0206ea4", "snowflake": "383310937b9286f8d0206ea4", @@ -5771,10 +5771,10 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "3efe8bb57c98fcbe74096b3c", "generic": "3efe8bb57c98fcbe74096b3c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1d8b945fd793ecdcacb90c21", -"postgres": "3efe8bb57c98fcbe74096b3c", -"postgresql": "3efe8bb57c98fcbe74096b3c", +"motherduck": "3efe8bb57c98fcbe74096b3c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "111af35848fe500ec2ae54b2", +"postgresql": "111af35848fe500ec2ae54b2", "snowflake": "1d8b945fd793ecdcacb90c21", "tsql": "3efe8bb57c98fcbe74096b3c" } @@ -5788,8 +5788,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -5805,10 +5805,10 @@ "databricks": "bbb97828cd28c64282709796", "duckdb": "bbb97828cd28c64282709796", "generic": "bbb97828cd28c64282709796", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "bbb97828cd28c64282709796", -"postgres": "bbb97828cd28c64282709796", -"postgresql": "bbb97828cd28c64282709796", +"motherduck": "bbb97828cd28c64282709796", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "b210f8eb26c37b422f786c6b", +"postgresql": "b210f8eb26c37b422f786c6b", "snowflake": "bbb97828cd28c64282709796", "tsql": "bbb97828cd28c64282709796" } @@ -5822,8 +5822,8 @@ "databricks": "33edbb37fe70dd760e97e937", "duckdb": "33edbb37fe70dd760e97e937", "generic": "33edbb37fe70dd760e97e937", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "33edbb37fe70dd760e97e937", +"motherduck": "33edbb37fe70dd760e97e937", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "33edbb37fe70dd760e97e937", "postgresql": "33edbb37fe70dd760e97e937", "snowflake": "33edbb37fe70dd760e97e937", @@ -5839,8 +5839,8 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "19a1a80ffc06169f32694de8", "postgresql": "19a1a80ffc06169f32694de8", "snowflake": "19a1a80ffc06169f32694de8", @@ -5856,8 +5856,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -5868,17 +5868,17 @@ "type", { "DuckDB": "d81d8c19074af0e39239164d", -"None": "1fec266134381c760a254d16", -"bigquery": "1fec266134381c760a254d16", -"databricks": "1fec266134381c760a254d16", +"None": "a2d22becd3f08974db215cfe", +"bigquery": "1e75e5227bea0ae294ac7af1", +"databricks": "a2d22becd3f08974db215cfe", "duckdb": "d81d8c19074af0e39239164d", -"generic": "1fec266134381c760a254d16", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1fec266134381c760a254d16", -"postgres": "1fec266134381c760a254d16", -"postgresql": "1fec266134381c760a254d16", +"generic": "a2d22becd3f08974db215cfe", +"motherduck": "d81d8c19074af0e39239164d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a2d22becd3f08974db215cfe", +"postgresql": "a2d22becd3f08974db215cfe", "snowflake": "1fec266134381c760a254d16", -"tsql": "1fec266134381c760a254d16" +"tsql": "a2d22becd3f08974db215cfe" } ], [ @@ -5890,8 +5890,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -5907,8 +5907,8 @@ "databricks": "558da38ec4d9d5d6c72f60cf", "duckdb": "0a735e1254c48785122ee5a3", "generic": "558da38ec4d9d5d6c72f60cf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "558da38ec4d9d5d6c72f60cf", +"motherduck": "0a735e1254c48785122ee5a3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "558da38ec4d9d5d6c72f60cf", "postgresql": "558da38ec4d9d5d6c72f60cf", "snowflake": "558da38ec4d9d5d6c72f60cf", @@ -5924,10 +5924,10 @@ "databricks": "38742651e9a5007a4262fae8", "duckdb": "38742651e9a5007a4262fae8", "generic": "38742651e9a5007a4262fae8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38742651e9a5007a4262fae8", -"postgres": "38742651e9a5007a4262fae8", -"postgresql": "38742651e9a5007a4262fae8", +"motherduck": "38742651e9a5007a4262fae8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "c5bb8c8a6d4b467b51e54a73", +"postgresql": "c5bb8c8a6d4b467b51e54a73", "snowflake": "38742651e9a5007a4262fae8", "tsql": "38742651e9a5007a4262fae8" } @@ -5937,14 +5937,14 @@ { "DuckDB": "de89632e277dbc8c97115419", "None": "de89632e277dbc8c97115419", -"bigquery": "de89632e277dbc8c97115419", +"bigquery": "5abf4ec799a2ec32fb10da7e", "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -5952,14 +5952,14 @@ [ "type", { -"DuckDB": "cdf6c5188287878061490c2a", +"DuckDB": "67646dac6abfc002a1e7cacf", "None": "cdf6c5188287878061490c2a", "bigquery": "8b225d02320fa30e4a4e6cb1", "databricks": "f6e9bda6dd824d392effea47", -"duckdb": "cdf6c5188287878061490c2a", +"duckdb": "67646dac6abfc002a1e7cacf", "generic": "cdf6c5188287878061490c2a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5598594492668be60871af14", +"motherduck": "67646dac6abfc002a1e7cacf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cdf6c5188287878061490c2a", "postgresql": "cdf6c5188287878061490c2a", "snowflake": "5c643769adf301c8da08643f", @@ -5975,8 +5975,8 @@ "databricks": "e7455ff80a579a99488df79b", "duckdb": "e7455ff80a579a99488df79b", "generic": "e7455ff80a579a99488df79b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e7455ff80a579a99488df79b", +"motherduck": "e7455ff80a579a99488df79b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e7455ff80a579a99488df79b", "postgresql": "e7455ff80a579a99488df79b", "snowflake": "e7455ff80a579a99488df79b", @@ -5992,10 +5992,10 @@ "databricks": "2c6b371b030464f525066893", "duckdb": "2c6b371b030464f525066893", "generic": "2c6b371b030464f525066893", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2c6b371b030464f525066893", -"postgres": "2c6b371b030464f525066893", -"postgresql": "2c6b371b030464f525066893", +"motherduck": "2c6b371b030464f525066893", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3feb479faeec777c2ade8afd", +"postgresql": "3feb479faeec777c2ade8afd", "snowflake": "2c6b371b030464f525066893", "tsql": "2c6b371b030464f525066893" } @@ -6005,14 +6005,14 @@ { "DuckDB": "881106a4a0d2de0ff7c56373", "None": "881106a4a0d2de0ff7c56373", -"bigquery": "881106a4a0d2de0ff7c56373", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "881106a4a0d2de0ff7c56373", "duckdb": "881106a4a0d2de0ff7c56373", "generic": "881106a4a0d2de0ff7c56373", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "881106a4a0d2de0ff7c56373", -"postgres": "881106a4a0d2de0ff7c56373", -"postgresql": "881106a4a0d2de0ff7c56373", +"motherduck": "881106a4a0d2de0ff7c56373", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "cf167ec395fc843602e3b1e0", +"postgresql": "cf167ec395fc843602e3b1e0", "snowflake": "881106a4a0d2de0ff7c56373", "tsql": "881106a4a0d2de0ff7c56373" } @@ -6022,12 +6022,12 @@ { "DuckDB": "461923a0d34defd0c726d6e5", "None": "461923a0d34defd0c726d6e5", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "461923a0d34defd0c726d6e5", "duckdb": "461923a0d34defd0c726d6e5", "generic": "461923a0d34defd0c726d6e5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "461923a0d34defd0c726d6e5", +"motherduck": "461923a0d34defd0c726d6e5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "461923a0d34defd0c726d6e5", "postgresql": "461923a0d34defd0c726d6e5", "snowflake": "461923a0d34defd0c726d6e5", @@ -6039,14 +6039,14 @@ { "DuckDB": "d2c97d221599d038d9875873", "None": "d2c97d221599d038d9875873", -"bigquery": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", "databricks": "d2c97d221599d038d9875873", "duckdb": "d2c97d221599d038d9875873", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "d2c97d221599d038d9875873", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -6056,12 +6056,12 @@ { "DuckDB": "07aa3fe366bb8a3f270ea3d3", "None": "07aa3fe366bb8a3f270ea3d3", -"bigquery": "07aa3fe366bb8a3f270ea3d3", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "07aa3fe366bb8a3f270ea3d3", "duckdb": "07aa3fe366bb8a3f270ea3d3", "generic": "07aa3fe366bb8a3f270ea3d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "07aa3fe366bb8a3f270ea3d3", +"motherduck": "07aa3fe366bb8a3f270ea3d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "07aa3fe366bb8a3f270ea3d3", "postgresql": "07aa3fe366bb8a3f270ea3d3", "snowflake": "07aa3fe366bb8a3f270ea3d3", @@ -6077,8 +6077,8 @@ "databricks": "d47776cdb5b03cf4b1e7b63c", "duckdb": "d47776cdb5b03cf4b1e7b63c", "generic": "d47776cdb5b03cf4b1e7b63c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d47776cdb5b03cf4b1e7b63c", +"motherduck": "d47776cdb5b03cf4b1e7b63c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d47776cdb5b03cf4b1e7b63c", "postgresql": "d47776cdb5b03cf4b1e7b63c", "snowflake": "d47776cdb5b03cf4b1e7b63c", @@ -6094,8 +6094,8 @@ "databricks": "eed0645c1e86fa1a6e35ccaa", "duckdb": "eed0645c1e86fa1a6e35ccaa", "generic": "eed0645c1e86fa1a6e35ccaa", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "eed0645c1e86fa1a6e35ccaa", +"motherduck": "eed0645c1e86fa1a6e35ccaa", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "eed0645c1e86fa1a6e35ccaa", "postgresql": "eed0645c1e86fa1a6e35ccaa", "snowflake": "97a20344d811fb77c7690863", @@ -6106,17 +6106,17 @@ "type", { "DuckDB": "a428302e4848ffe877284c84", -"None": "a428302e4848ffe877284c84", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "a428302e4848ffe877284c84", +"None": "c9b810639795a7bfab91b98d", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "c9b810639795a7bfab91b98d", "duckdb": "a428302e4848ffe877284c84", -"generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"generic": "c9b810639795a7bfab91b98d", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "a428302e4848ffe877284c84" +"tsql": "c9b810639795a7bfab91b98d" } ], [ @@ -6128,8 +6128,8 @@ "databricks": "3959952046272deb40567543", "duckdb": "3959952046272deb40567543", "generic": "3959952046272deb40567543", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3959952046272deb40567543", +"motherduck": "3959952046272deb40567543", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3959952046272deb40567543", "postgresql": "3959952046272deb40567543", "snowflake": "3959952046272deb40567543", @@ -6145,8 +6145,8 @@ "databricks": "c426d93641829fa3d8f49b8d", "duckdb": "c426d93641829fa3d8f49b8d", "generic": "c426d93641829fa3d8f49b8d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c426d93641829fa3d8f49b8d", +"motherduck": "c426d93641829fa3d8f49b8d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c426d93641829fa3d8f49b8d", "postgresql": "c426d93641829fa3d8f49b8d", "snowflake": "c426d93641829fa3d8f49b8d", @@ -6162,8 +6162,8 @@ "databricks": "da33de41a707d0e067e415fd", "duckdb": "da33de41a707d0e067e415fd", "generic": "da33de41a707d0e067e415fd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "da33de41a707d0e067e415fd", +"motherduck": "da33de41a707d0e067e415fd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "da33de41a707d0e067e415fd", "postgresql": "da33de41a707d0e067e415fd", "snowflake": "da33de41a707d0e067e415fd", @@ -6174,17 +6174,17 @@ "type", { "DuckDB": "3147a9e06daa6de4a4df5abc", -"None": "3147a9e06daa6de4a4df5abc", -"bigquery": "f276e907770196606577c932", -"databricks": "3147a9e06daa6de4a4df5abc", +"None": "da0625706f12b764a6912278", +"bigquery": "b0477b36767a62145aa9158c", +"databricks": "da0625706f12b764a6912278", "duckdb": "3147a9e06daa6de4a4df5abc", -"generic": "3147a9e06daa6de4a4df5abc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3147a9e06daa6de4a4df5abc", +"generic": "da0625706f12b764a6912278", +"motherduck": "3147a9e06daa6de4a4df5abc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3147a9e06daa6de4a4df5abc", "postgresql": "3147a9e06daa6de4a4df5abc", "snowflake": "67b5874a2c569226c490211f", -"tsql": "3147a9e06daa6de4a4df5abc" +"tsql": "da0625706f12b764a6912278" } ], [ @@ -6196,10 +6196,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -6213,8 +6213,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -6230,8 +6230,8 @@ "databricks": "be15dde1d6e0b4bb3f6da66f", "duckdb": "be15dde1d6e0b4bb3f6da66f", "generic": "be15dde1d6e0b4bb3f6da66f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "be15dde1d6e0b4bb3f6da66f", +"motherduck": "be15dde1d6e0b4bb3f6da66f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "be15dde1d6e0b4bb3f6da66f", "postgresql": "be15dde1d6e0b4bb3f6da66f", "snowflake": "be15dde1d6e0b4bb3f6da66f", @@ -6247,8 +6247,8 @@ "databricks": "5aa51d84ac5e6c7a9306f348", "duckdb": "5aa51d84ac5e6c7a9306f348", "generic": "5aa51d84ac5e6c7a9306f348", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5aa51d84ac5e6c7a9306f348", +"motherduck": "5aa51d84ac5e6c7a9306f348", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5aa51d84ac5e6c7a9306f348", "postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "5aa51d84ac5e6c7a9306f348", @@ -6260,14 +6260,14 @@ { "DuckDB": "73151c1398b30e5c5d18f4ce", "None": "73151c1398b30e5c5d18f4ce", -"bigquery": "73151c1398b30e5c5d18f4ce", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "73151c1398b30e5c5d18f4ce", "duckdb": "73151c1398b30e5c5d18f4ce", "generic": "73151c1398b30e5c5d18f4ce", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73151c1398b30e5c5d18f4ce", -"postgres": "73151c1398b30e5c5d18f4ce", -"postgresql": "73151c1398b30e5c5d18f4ce", +"motherduck": "73151c1398b30e5c5d18f4ce", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f68b7dbd74ec7c3b9f3066ef", +"postgresql": "f68b7dbd74ec7c3b9f3066ef", "snowflake": "73151c1398b30e5c5d18f4ce", "tsql": "73151c1398b30e5c5d18f4ce" } @@ -6278,11 +6278,11 @@ "DuckDB": "e3d9a113277b9c69432b32d1", "None": "e3d9a113277b9c69432b32d1", "bigquery": "e3d9a113277b9c69432b32d1", -"databricks": "4cda99191af9adfbe91e70f6", +"databricks": "e3d9a113277b9c69432b32d1", "duckdb": "e3d9a113277b9c69432b32d1", "generic": "e3d9a113277b9c69432b32d1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4cda99191af9adfbe91e70f6", +"motherduck": "e3d9a113277b9c69432b32d1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e3d9a113277b9c69432b32d1", "postgresql": "e3d9a113277b9c69432b32d1", "snowflake": "e3d9a113277b9c69432b32d1", @@ -6298,8 +6298,8 @@ "databricks": "b137c998bdaa2555d912e8fa", "duckdb": "27f973a6b2da27a79f5c0074", "generic": "b137c998bdaa2555d912e8fa", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b137c998bdaa2555d912e8fa", +"motherduck": "27f973a6b2da27a79f5c0074", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b137c998bdaa2555d912e8fa", "postgresql": "b137c998bdaa2555d912e8fa", "snowflake": "b137c998bdaa2555d912e8fa", @@ -6315,8 +6315,8 @@ "databricks": "7a924f1a13854aa3260f3f57", "duckdb": "7a924f1a13854aa3260f3f57", "generic": "7a924f1a13854aa3260f3f57", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7a924f1a13854aa3260f3f57", +"motherduck": "7a924f1a13854aa3260f3f57", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7a924f1a13854aa3260f3f57", "postgresql": "7a924f1a13854aa3260f3f57", "snowflake": "7a924f1a13854aa3260f3f57", @@ -6332,8 +6332,8 @@ "databricks": "d90a78129f7050a540984f6f", "duckdb": "66f7ca02161349d637fa7d4e", "generic": "66f7ca02161349d637fa7d4e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d90a78129f7050a540984f6f", +"motherduck": "66f7ca02161349d637fa7d4e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "66f7ca02161349d637fa7d4e", "postgresql": "66f7ca02161349d637fa7d4e", "snowflake": "66f7ca02161349d637fa7d4e", @@ -6349,8 +6349,8 @@ "databricks": "104d3e046c47032c37f947b8", "duckdb": "104d3e046c47032c37f947b8", "generic": "104d3e046c47032c37f947b8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "104d3e046c47032c37f947b8", +"motherduck": "104d3e046c47032c37f947b8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "104d3e046c47032c37f947b8", "postgresql": "104d3e046c47032c37f947b8", "snowflake": "104d3e046c47032c37f947b8", @@ -6366,8 +6366,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -6383,8 +6383,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -6400,8 +6400,8 @@ "databricks": "f3150219c38dba6b9f922447", "duckdb": "f3150219c38dba6b9f922447", "generic": "f3150219c38dba6b9f922447", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f3150219c38dba6b9f922447", +"motherduck": "f3150219c38dba6b9f922447", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f3150219c38dba6b9f922447", "postgresql": "f3150219c38dba6b9f922447", "snowflake": "f3150219c38dba6b9f922447", @@ -6417,8 +6417,8 @@ "databricks": "f6140be64a327a15b42b923d", "duckdb": "f6140be64a327a15b42b923d", "generic": "f6140be64a327a15b42b923d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f6140be64a327a15b42b923d", +"motherduck": "f6140be64a327a15b42b923d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f6140be64a327a15b42b923d", "postgresql": "f6140be64a327a15b42b923d", "snowflake": "f6140be64a327a15b42b923d", @@ -6430,14 +6430,14 @@ { "DuckDB": "e408f2d8251e1675179187e6", "None": "e408f2d8251e1675179187e6", -"bigquery": "e408f2d8251e1675179187e6", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "e408f2d8251e1675179187e6", "duckdb": "e408f2d8251e1675179187e6", "generic": "e408f2d8251e1675179187e6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e408f2d8251e1675179187e6", -"postgres": "e408f2d8251e1675179187e6", -"postgresql": "e408f2d8251e1675179187e6", +"motherduck": "e408f2d8251e1675179187e6", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "04bfa329b4dc3b5c43ad2560", +"postgresql": "04bfa329b4dc3b5c43ad2560", "snowflake": "e408f2d8251e1675179187e6", "tsql": "e408f2d8251e1675179187e6" } @@ -6451,8 +6451,8 @@ "databricks": "3959952046272deb40567543", "duckdb": "3959952046272deb40567543", "generic": "3959952046272deb40567543", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3959952046272deb40567543", +"motherduck": "3959952046272deb40567543", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3959952046272deb40567543", "postgresql": "3959952046272deb40567543", "snowflake": "3959952046272deb40567543", @@ -6468,8 +6468,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -6480,17 +6480,17 @@ "type", { "DuckDB": "087a9417cb511ff7bcfd6ccb", -"None": "383f8922f4b6f167d384037d", -"bigquery": "383f8922f4b6f167d384037d", -"databricks": "383f8922f4b6f167d384037d", +"None": "2e8f6dfec4597fb9373329e7", +"bigquery": "2e8f6dfec4597fb9373329e7", +"databricks": "2e8f6dfec4597fb9373329e7", "duckdb": "087a9417cb511ff7bcfd6ccb", -"generic": "383f8922f4b6f167d384037d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "383f8922f4b6f167d384037d", +"generic": "2e8f6dfec4597fb9373329e7", +"motherduck": "087a9417cb511ff7bcfd6ccb", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "383f8922f4b6f167d384037d", "postgresql": "383f8922f4b6f167d384037d", "snowflake": "383f8922f4b6f167d384037d", -"tsql": "383f8922f4b6f167d384037d" +"tsql": "2e8f6dfec4597fb9373329e7" } ], [ @@ -6502,8 +6502,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -6519,8 +6519,8 @@ "databricks": "5d0a19a893dbf0c1e6e9f15c", "duckdb": "5d0a19a893dbf0c1e6e9f15c", "generic": "5d0a19a893dbf0c1e6e9f15c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d0a19a893dbf0c1e6e9f15c", +"motherduck": "5d0a19a893dbf0c1e6e9f15c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5d0a19a893dbf0c1e6e9f15c", "postgresql": "5d0a19a893dbf0c1e6e9f15c", "snowflake": "5d0a19a893dbf0c1e6e9f15c", @@ -6536,8 +6536,8 @@ "databricks": "2460e6e632163bbe7ecaf8a2", "duckdb": "2460e6e632163bbe7ecaf8a2", "generic": "2460e6e632163bbe7ecaf8a2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2460e6e632163bbe7ecaf8a2", +"motherduck": "2460e6e632163bbe7ecaf8a2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2460e6e632163bbe7ecaf8a2", "postgresql": "2460e6e632163bbe7ecaf8a2", "snowflake": "2460e6e632163bbe7ecaf8a2", @@ -6549,14 +6549,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -6570,8 +6570,8 @@ "databricks": "3b0d47536653277b7d98e328", "duckdb": "3b0d47536653277b7d98e328", "generic": "3b0d47536653277b7d98e328", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3b0d47536653277b7d98e328", +"motherduck": "3b0d47536653277b7d98e328", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3b0d47536653277b7d98e328", "postgresql": "3b0d47536653277b7d98e328", "snowflake": "3b0d47536653277b7d98e328", @@ -6587,8 +6587,8 @@ "databricks": "8352e528bde15549f0d0d870", "duckdb": "da08a000bb111759556a61cc", "generic": "df518e3c53cd9a166efacdb4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73477f3a6e7e1fd4288ea98f", +"motherduck": "da08a000bb111759556a61cc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "df518e3c53cd9a166efacdb4", "postgresql": "df518e3c53cd9a166efacdb4", "snowflake": "58581fd57ff3a9d0f74420dc", @@ -6601,11 +6601,11 @@ "DuckDB": "1f9deff638e476a7f168220b", "None": "1f9deff638e476a7f168220b", "bigquery": "1f9deff638e476a7f168220b", -"databricks": "eeac51d8e73fdd4f598fd1cd", +"databricks": "1f9deff638e476a7f168220b", "duckdb": "1f9deff638e476a7f168220b", "generic": "1f9deff638e476a7f168220b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "eeac51d8e73fdd4f598fd1cd", +"motherduck": "1f9deff638e476a7f168220b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1f9deff638e476a7f168220b", "postgresql": "1f9deff638e476a7f168220b", "snowflake": "1f9deff638e476a7f168220b", @@ -6617,12 +6617,12 @@ { "DuckDB": "ebfad3a0b99f87bcac831ded", "None": "ebfad3a0b99f87bcac831ded", -"bigquery": "ebfad3a0b99f87bcac831ded", +"bigquery": "6da3227d362b48323df57544", "databricks": "ebfad3a0b99f87bcac831ded", "duckdb": "ebfad3a0b99f87bcac831ded", "generic": "ebfad3a0b99f87bcac831ded", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebfad3a0b99f87bcac831ded", +"motherduck": "ebfad3a0b99f87bcac831ded", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebfad3a0b99f87bcac831ded", "postgresql": "ebfad3a0b99f87bcac831ded", "snowflake": "ebfad3a0b99f87bcac831ded", @@ -6638,8 +6638,8 @@ "databricks": "4281b54de06f589b3507035a", "duckdb": "5620e893a908c6743b863bf6", "generic": "5620e893a908c6743b863bf6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4281b54de06f589b3507035a", +"motherduck": "5620e893a908c6743b863bf6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5620e893a908c6743b863bf6", "postgresql": "5620e893a908c6743b863bf6", "snowflake": "5620e893a908c6743b863bf6", @@ -6655,8 +6655,8 @@ "databricks": "48b9d23d0bb10c99b1325f6b", "duckdb": "48b9d23d0bb10c99b1325f6b", "generic": "48b9d23d0bb10c99b1325f6b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "48b9d23d0bb10c99b1325f6b", +"motherduck": "48b9d23d0bb10c99b1325f6b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "48b9d23d0bb10c99b1325f6b", "postgresql": "48b9d23d0bb10c99b1325f6b", "snowflake": "48b9d23d0bb10c99b1325f6b", @@ -6672,8 +6672,8 @@ "databricks": "8f0cf40e26c5ef0cbf1da302", "duckdb": "024a48135994929163b8f97b", "generic": "8f0cf40e26c5ef0cbf1da302", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "024a48135994929163b8f97b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "024a48135994929163b8f97b", "postgresql": "024a48135994929163b8f97b", "snowflake": "cc36c0fadc1a5838c69f0b9e", @@ -6685,14 +6685,14 @@ { "DuckDB": "4d0f0db1a550ed1e0da1a043", "None": "4d0f0db1a550ed1e0da1a043", -"bigquery": "4d0f0db1a550ed1e0da1a043", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "4d0f0db1a550ed1e0da1a043", "duckdb": "4d0f0db1a550ed1e0da1a043", "generic": "4d0f0db1a550ed1e0da1a043", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4d0f0db1a550ed1e0da1a043", -"postgres": "4d0f0db1a550ed1e0da1a043", -"postgresql": "4d0f0db1a550ed1e0da1a043", +"motherduck": "4d0f0db1a550ed1e0da1a043", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e47320d1030c166a05193bc4", +"postgresql": "e47320d1030c166a05193bc4", "snowflake": "4d0f0db1a550ed1e0da1a043", "tsql": "4d0f0db1a550ed1e0da1a043" } @@ -6706,8 +6706,8 @@ "databricks": "1275b5b0c52f69cf592c004b", "duckdb": "1275b5b0c52f69cf592c004b", "generic": "1275b5b0c52f69cf592c004b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1275b5b0c52f69cf592c004b", +"motherduck": "1275b5b0c52f69cf592c004b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1275b5b0c52f69cf592c004b", "postgresql": "1275b5b0c52f69cf592c004b", "snowflake": "1275b5b0c52f69cf592c004b", @@ -6723,8 +6723,8 @@ "databricks": "fb5907c56dd752ac5f1dbd95", "duckdb": "fb5907c56dd752ac5f1dbd95", "generic": "fb5907c56dd752ac5f1dbd95", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fb5907c56dd752ac5f1dbd95", +"motherduck": "fb5907c56dd752ac5f1dbd95", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fb5907c56dd752ac5f1dbd95", "postgresql": "fb5907c56dd752ac5f1dbd95", "snowflake": "fb5907c56dd752ac5f1dbd95", @@ -6740,8 +6740,8 @@ "databricks": "c82815abe30b3d099903f838", "duckdb": "c82815abe30b3d099903f838", "generic": "c82815abe30b3d099903f838", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c82815abe30b3d099903f838", +"motherduck": "c82815abe30b3d099903f838", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c82815abe30b3d099903f838", "postgresql": "c82815abe30b3d099903f838", "snowflake": "c82815abe30b3d099903f838", @@ -6757,8 +6757,8 @@ "databricks": "182a094bae8a9a33f67845ad", "duckdb": "182a094bae8a9a33f67845ad", "generic": "182a094bae8a9a33f67845ad", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "182a094bae8a9a33f67845ad", +"motherduck": "182a094bae8a9a33f67845ad", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "182a094bae8a9a33f67845ad", "postgresql": "182a094bae8a9a33f67845ad", "snowflake": "182a094bae8a9a33f67845ad", @@ -6774,8 +6774,8 @@ "databricks": "f4c43a87a78970bca1f88b09", "duckdb": "f4c43a87a78970bca1f88b09", "generic": "f4c43a87a78970bca1f88b09", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f4c43a87a78970bca1f88b09", +"motherduck": "f4c43a87a78970bca1f88b09", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f4c43a87a78970bca1f88b09", "postgresql": "f4c43a87a78970bca1f88b09", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -6791,8 +6791,8 @@ "databricks": "330fec4d6c49ac503e302b43", "duckdb": "330fec4d6c49ac503e302b43", "generic": "330fec4d6c49ac503e302b43", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "330fec4d6c49ac503e302b43", +"motherduck": "330fec4d6c49ac503e302b43", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f38ef32a483f1c4f89ae309e", "postgresql": "f38ef32a483f1c4f89ae309e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -6808,10 +6808,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -6821,12 +6821,12 @@ { "DuckDB": "8203bd5901a8ec71ff7c103e", "None": "8203bd5901a8ec71ff7c103e", -"bigquery": "2a0918be53051fe629d9ff8f", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "8203bd5901a8ec71ff7c103e", "duckdb": "8203bd5901a8ec71ff7c103e", "generic": "8203bd5901a8ec71ff7c103e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8203bd5901a8ec71ff7c103e", +"motherduck": "8203bd5901a8ec71ff7c103e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8203bd5901a8ec71ff7c103e", "postgresql": "8203bd5901a8ec71ff7c103e", "snowflake": "8203bd5901a8ec71ff7c103e", @@ -6842,10 +6842,10 @@ "databricks": "9ff8ffdba7614214fe44bd7f", "duckdb": "9ff8ffdba7614214fe44bd7f", "generic": "9ff8ffdba7614214fe44bd7f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9ff8ffdba7614214fe44bd7f", -"postgres": "9ff8ffdba7614214fe44bd7f", -"postgresql": "9ff8ffdba7614214fe44bd7f", +"motherduck": "9ff8ffdba7614214fe44bd7f", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "12a93f1979dd590479e084a8", +"postgresql": "12a93f1979dd590479e084a8", "snowflake": "9ff8ffdba7614214fe44bd7f", "tsql": "9ff8ffdba7614214fe44bd7f" } @@ -6859,10 +6859,10 @@ "databricks": "336fd1b7a1f7d8105c29280c", "duckdb": "0baaca265927140414f32b37", "generic": "336fd1b7a1f7d8105c29280c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "336fd1b7a1f7d8105c29280c", -"postgres": "336fd1b7a1f7d8105c29280c", -"postgresql": "336fd1b7a1f7d8105c29280c", +"motherduck": "0baaca265927140414f32b37", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9ea4932505663b43f527adad", +"postgresql": "9ea4932505663b43f527adad", "snowflake": "336fd1b7a1f7d8105c29280c", "tsql": "336fd1b7a1f7d8105c29280c" } @@ -6871,17 +6871,17 @@ "type", { "DuckDB": "fa45b7e4a9ef3b5a9c5781af", -"None": "fa45b7e4a9ef3b5a9c5781af", -"bigquery": "fa45b7e4a9ef3b5a9c5781af", -"databricks": "fa45b7e4a9ef3b5a9c5781af", +"None": "ebe2513b6cb4001e42cc464b", +"bigquery": "0c43dc837a50933667588ef1", +"databricks": "ebe2513b6cb4001e42cc464b", "duckdb": "fa45b7e4a9ef3b5a9c5781af", -"generic": "fa45b7e4a9ef3b5a9c5781af", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fa45b7e4a9ef3b5a9c5781af", +"generic": "ebe2513b6cb4001e42cc464b", +"motherduck": "fa45b7e4a9ef3b5a9c5781af", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fa45b7e4a9ef3b5a9c5781af", "postgresql": "fa45b7e4a9ef3b5a9c5781af", "snowflake": "fa45b7e4a9ef3b5a9c5781af", -"tsql": "fa45b7e4a9ef3b5a9c5781af" +"tsql": "ebe2513b6cb4001e42cc464b" } ], [ @@ -6893,8 +6893,8 @@ "databricks": "a22797fa0ef22aadba4ac3ec", "duckdb": "a22797fa0ef22aadba4ac3ec", "generic": "a22797fa0ef22aadba4ac3ec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a22797fa0ef22aadba4ac3ec", +"motherduck": "a22797fa0ef22aadba4ac3ec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a22797fa0ef22aadba4ac3ec", "postgresql": "a22797fa0ef22aadba4ac3ec", "snowflake": "a22797fa0ef22aadba4ac3ec", @@ -6906,14 +6906,14 @@ { "DuckDB": "881106a4a0d2de0ff7c56373", "None": "881106a4a0d2de0ff7c56373", -"bigquery": "881106a4a0d2de0ff7c56373", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "881106a4a0d2de0ff7c56373", "duckdb": "881106a4a0d2de0ff7c56373", "generic": "881106a4a0d2de0ff7c56373", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "881106a4a0d2de0ff7c56373", -"postgres": "881106a4a0d2de0ff7c56373", -"postgresql": "881106a4a0d2de0ff7c56373", +"motherduck": "881106a4a0d2de0ff7c56373", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "cf167ec395fc843602e3b1e0", +"postgresql": "cf167ec395fc843602e3b1e0", "snowflake": "881106a4a0d2de0ff7c56373", "tsql": "881106a4a0d2de0ff7c56373" } @@ -6927,10 +6927,10 @@ "databricks": "2705f19942a4194a72576911", "duckdb": "2705f19942a4194a72576911", "generic": "2705f19942a4194a72576911", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2705f19942a4194a72576911", -"postgres": "2705f19942a4194a72576911", -"postgresql": "2705f19942a4194a72576911", +"motherduck": "2705f19942a4194a72576911", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5226d7e2a62c7650a87d6e84", +"postgresql": "5226d7e2a62c7650a87d6e84", "snowflake": "2705f19942a4194a72576911", "tsql": "2705f19942a4194a72576911" } @@ -6944,8 +6944,8 @@ "databricks": "79483dab720e706b74936744", "duckdb": "79483dab720e706b74936744", "generic": "79483dab720e706b74936744", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79483dab720e706b74936744", +"motherduck": "79483dab720e706b74936744", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79483dab720e706b74936744", "postgresql": "79483dab720e706b74936744", "snowflake": "79483dab720e706b74936744", @@ -6961,8 +6961,8 @@ "databricks": "7032aa8254308ba815883957", "duckdb": "7032aa8254308ba815883957", "generic": "7032aa8254308ba815883957", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7032aa8254308ba815883957", +"motherduck": "7032aa8254308ba815883957", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7032aa8254308ba815883957", "postgresql": "7032aa8254308ba815883957", "snowflake": "7032aa8254308ba815883957", @@ -6978,10 +6978,10 @@ "databricks": "6f763a99e9c69109526b40c0", "duckdb": "6f763a99e9c69109526b40c0", "generic": "6f763a99e9c69109526b40c0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6f763a99e9c69109526b40c0", -"postgres": "6f763a99e9c69109526b40c0", -"postgresql": "6f763a99e9c69109526b40c0", +"motherduck": "6f763a99e9c69109526b40c0", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5226d7e2a62c7650a87d6e84", +"postgresql": "5226d7e2a62c7650a87d6e84", "snowflake": "2705f19942a4194a72576911", "tsql": "6f763a99e9c69109526b40c0" } @@ -6990,17 +6990,17 @@ "type", { "DuckDB": "d9a22eb846c0561f4d74700b", -"None": "d9a22eb846c0561f4d74700b", -"bigquery": "d9a22eb846c0561f4d74700b", -"databricks": "d9a22eb846c0561f4d74700b", +"None": "93edc94c44e0732b1be558b1", +"bigquery": "93edc94c44e0732b1be558b1", +"databricks": "93edc94c44e0732b1be558b1", "duckdb": "d9a22eb846c0561f4d74700b", -"generic": "d9a22eb846c0561f4d74700b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d9a22eb846c0561f4d74700b", +"generic": "93edc94c44e0732b1be558b1", +"motherduck": "d9a22eb846c0561f4d74700b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d9a22eb846c0561f4d74700b", "postgresql": "d9a22eb846c0561f4d74700b", "snowflake": "9b5f44707b5f4764b82741be", -"tsql": "d9a22eb846c0561f4d74700b" +"tsql": "93edc94c44e0732b1be558b1" } ], [ @@ -7012,8 +7012,8 @@ "databricks": "ce3765fd18ee6aff1394ac23", "duckdb": "ce3765fd18ee6aff1394ac23", "generic": "ce3765fd18ee6aff1394ac23", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ce3765fd18ee6aff1394ac23", +"motherduck": "ce3765fd18ee6aff1394ac23", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ce3765fd18ee6aff1394ac23", "postgresql": "ce3765fd18ee6aff1394ac23", "snowflake": "ce3765fd18ee6aff1394ac23", @@ -7024,17 +7024,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -7046,8 +7046,8 @@ "databricks": "78b2cf275c640af54feeca31", "duckdb": "78b2cf275c640af54feeca31", "generic": "78b2cf275c640af54feeca31", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "78b2cf275c640af54feeca31", +"motherduck": "78b2cf275c640af54feeca31", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "78b2cf275c640af54feeca31", "postgresql": "78b2cf275c640af54feeca31", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -7063,8 +7063,8 @@ "databricks": "87eaac3f093587d1d34762da", "duckdb": "87eaac3f093587d1d34762da", "generic": "87eaac3f093587d1d34762da", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "87eaac3f093587d1d34762da", +"motherduck": "87eaac3f093587d1d34762da", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "87eaac3f093587d1d34762da", "postgresql": "87eaac3f093587d1d34762da", "snowflake": "87eaac3f093587d1d34762da", @@ -7080,10 +7080,10 @@ "databricks": "5d25d5e13f81700741695ed4", "duckdb": "5d25d5e13f81700741695ed4", "generic": "5d25d5e13f81700741695ed4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d25d5e13f81700741695ed4", -"postgres": "5d25d5e13f81700741695ed4", -"postgresql": "5d25d5e13f81700741695ed4", +"motherduck": "5d25d5e13f81700741695ed4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "62131fb5b065f5de2e74a0f1", +"postgresql": "62131fb5b065f5de2e74a0f1", "snowflake": "5d25d5e13f81700741695ed4", "tsql": "5d25d5e13f81700741695ed4" } @@ -7097,10 +7097,10 @@ "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -7110,14 +7110,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -7131,8 +7131,8 @@ "databricks": "97cf3d84c55104df9751ec06", "duckdb": "97cf3d84c55104df9751ec06", "generic": "97cf3d84c55104df9751ec06", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "97cf3d84c55104df9751ec06", +"motherduck": "97cf3d84c55104df9751ec06", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "97cf3d84c55104df9751ec06", "postgresql": "97cf3d84c55104df9751ec06", "snowflake": "97cf3d84c55104df9751ec06", @@ -7148,8 +7148,8 @@ "databricks": "0703bf71a54942bdaa28406e", "duckdb": "0703bf71a54942bdaa28406e", "generic": "0703bf71a54942bdaa28406e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0703bf71a54942bdaa28406e", +"motherduck": "0703bf71a54942bdaa28406e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0703bf71a54942bdaa28406e", "postgresql": "0703bf71a54942bdaa28406e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -7161,12 +7161,12 @@ { "DuckDB": "18db5afe2c1e80d1ee652b54", "None": "18db5afe2c1e80d1ee652b54", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "18db5afe2c1e80d1ee652b54", "duckdb": "18db5afe2c1e80d1ee652b54", "generic": "18db5afe2c1e80d1ee652b54", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "18db5afe2c1e80d1ee652b54", +"motherduck": "18db5afe2c1e80d1ee652b54", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "18db5afe2c1e80d1ee652b54", "postgresql": "18db5afe2c1e80d1ee652b54", "snowflake": "18db5afe2c1e80d1ee652b54", @@ -7178,12 +7178,12 @@ { "DuckDB": "5e46ad7c70253689a5c6bb7f", "None": "5e46ad7c70253689a5c6bb7f", -"bigquery": "5e46ad7c70253689a5c6bb7f", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "5e46ad7c70253689a5c6bb7f", "duckdb": "5e46ad7c70253689a5c6bb7f", "generic": "5e46ad7c70253689a5c6bb7f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5e46ad7c70253689a5c6bb7f", +"motherduck": "5e46ad7c70253689a5c6bb7f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5e46ad7c70253689a5c6bb7f", "postgresql": "5e46ad7c70253689a5c6bb7f", "snowflake": "5e46ad7c70253689a5c6bb7f", @@ -7194,17 +7194,17 @@ "type", { "DuckDB": "3147a9e06daa6de4a4df5abc", -"None": "3147a9e06daa6de4a4df5abc", -"bigquery": "f276e907770196606577c932", -"databricks": "3147a9e06daa6de4a4df5abc", +"None": "da0625706f12b764a6912278", +"bigquery": "b0477b36767a62145aa9158c", +"databricks": "da0625706f12b764a6912278", "duckdb": "3147a9e06daa6de4a4df5abc", -"generic": "3147a9e06daa6de4a4df5abc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3147a9e06daa6de4a4df5abc", +"generic": "da0625706f12b764a6912278", +"motherduck": "3147a9e06daa6de4a4df5abc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3147a9e06daa6de4a4df5abc", "postgresql": "3147a9e06daa6de4a4df5abc", "snowflake": "67b5874a2c569226c490211f", -"tsql": "3147a9e06daa6de4a4df5abc" +"tsql": "da0625706f12b764a6912278" } ], [ @@ -7216,8 +7216,8 @@ "databricks": "8789309b90fc585ddbbe90f9", "duckdb": "8789309b90fc585ddbbe90f9", "generic": "8789309b90fc585ddbbe90f9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8789309b90fc585ddbbe90f9", +"motherduck": "8789309b90fc585ddbbe90f9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8789309b90fc585ddbbe90f9", "postgresql": "8789309b90fc585ddbbe90f9", "snowflake": "8789309b90fc585ddbbe90f9", @@ -7233,8 +7233,8 @@ "databricks": "5990107b647ce24001477492", "duckdb": "5990107b647ce24001477492", "generic": "5990107b647ce24001477492", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5990107b647ce24001477492", +"motherduck": "5990107b647ce24001477492", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5990107b647ce24001477492", "postgresql": "5990107b647ce24001477492", "snowflake": "5990107b647ce24001477492", @@ -7250,8 +7250,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "8441d00030df06ad6a5534d3", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "8441d00030df06ad6a5534d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -7267,8 +7267,8 @@ "databricks": "f15c56475abfc73488abe63b", "duckdb": "f15c56475abfc73488abe63b", "generic": "f15c56475abfc73488abe63b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f15c56475abfc73488abe63b", +"motherduck": "f15c56475abfc73488abe63b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f15c56475abfc73488abe63b", "postgresql": "f15c56475abfc73488abe63b", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -7284,10 +7284,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -7296,15 +7296,15 @@ "type", { "DuckDB": "8317b957016bdf11135b4836", -"None": "0a21e78538ff353d773b4eea", -"bigquery": "0a21e78538ff353d773b4eea", -"databricks": "0a21e78538ff353d773b4eea", +"None": "45310b1154cae517b4caedff", +"bigquery": "45310b1154cae517b4caedff", +"databricks": "45310b1154cae517b4caedff", "duckdb": "8317b957016bdf11135b4836", -"generic": "0a21e78538ff353d773b4eea", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "8317b957016bdf11135b4836", -"postgresql": "8317b957016bdf11135b4836", +"generic": "45310b1154cae517b4caedff", +"motherduck": "8317b957016bdf11135b4836", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "45310b1154cae517b4caedff", +"postgresql": "45310b1154cae517b4caedff", "snowflake": "c2976683dc7003c9f4e8d7d0", "tsql": "45310b1154cae517b4caedff" } @@ -7312,18 +7312,18 @@ [ "type", { -"DuckDB": "e72e438b895cc91eaf4be018", -"None": "a1b6a3abd5c2785b419400de", -"bigquery": "f4105e8e41859869d2746e1d", -"databricks": "a1b6a3abd5c2785b419400de", -"duckdb": "e72e438b895cc91eaf4be018", -"generic": "a1b6a3abd5c2785b419400de", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a1b6a3abd5c2785b419400de", -"postgres": "a1b6a3abd5c2785b419400de", -"postgresql": "a1b6a3abd5c2785b419400de", +"DuckDB": "f77bad2342e566026c6930f9", +"None": "325bc7668cc9012c12196cbf", +"bigquery": "325bc7668cc9012c12196cbf", +"databricks": "325bc7668cc9012c12196cbf", +"duckdb": "f77bad2342e566026c6930f9", +"generic": "325bc7668cc9012c12196cbf", +"motherduck": "f77bad2342e566026c6930f9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "6031cfaf0d57e25f8a111524", +"postgresql": "6031cfaf0d57e25f8a111524", "snowflake": "6031cfaf0d57e25f8a111524", -"tsql": "a1b6a3abd5c2785b419400de" +"tsql": "325bc7668cc9012c12196cbf" } ], [ @@ -7335,8 +7335,8 @@ "databricks": "eea1002d88cc68fad7424aca", "duckdb": "c729c38d2df6efedc6288247", "generic": "eea1002d88cc68fad7424aca", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "eea1002d88cc68fad7424aca", +"motherduck": "c729c38d2df6efedc6288247", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "eea1002d88cc68fad7424aca", "postgresql": "eea1002d88cc68fad7424aca", "snowflake": "eea1002d88cc68fad7424aca", @@ -7347,17 +7347,17 @@ "type", { "DuckDB": "1ebac487198b6c90b027faab", -"None": "1ebac487198b6c90b027faab", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "1ebac487198b6c90b027faab", +"None": "1eb7fb4e8cf75773c5573562", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1ebac487198b6c90b027faab", -"generic": "1ebac487198b6c90b027faab", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1ebac487198b6c90b027faab", -"postgres": "1ebac487198b6c90b027faab", -"postgresql": "1ebac487198b6c90b027faab", -"snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "c692d974ee3f362ecb38f27c" +"generic": "1eb7fb4e8cf75773c5573562", +"motherduck": "1ebac487198b6c90b027faab", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "1eb7fb4e8cf75773c5573562", +"postgresql": "1eb7fb4e8cf75773c5573562", +"snowflake": "97a20344d811fb77c7690863", +"tsql": "1eb7fb4e8cf75773c5573562" } ], [ @@ -7369,8 +7369,8 @@ "databricks": "1a804f317a3e9a0016925b04", "duckdb": "110327dc45eac0e8d54a96dc", "generic": "110327dc45eac0e8d54a96dc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1a804f317a3e9a0016925b04", +"motherduck": "110327dc45eac0e8d54a96dc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "110327dc45eac0e8d54a96dc", "postgresql": "110327dc45eac0e8d54a96dc", "snowflake": "110327dc45eac0e8d54a96dc", @@ -7386,8 +7386,8 @@ "databricks": "8562dfdaf4f03fa06585b288", "duckdb": "8562dfdaf4f03fa06585b288", "generic": "8562dfdaf4f03fa06585b288", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8562dfdaf4f03fa06585b288", +"motherduck": "8562dfdaf4f03fa06585b288", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8562dfdaf4f03fa06585b288", "postgresql": "8562dfdaf4f03fa06585b288", "snowflake": "8562dfdaf4f03fa06585b288", @@ -7403,8 +7403,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -7416,14 +7416,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -7437,8 +7437,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -7454,8 +7454,8 @@ "databricks": "0111ff4826a58e7709648841", "duckdb": "a0f9ede1ffaaa874ee2066b3", "generic": "a0f9ede1ffaaa874ee2066b3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a0f9ede1ffaaa874ee2066b3", +"motherduck": "a0f9ede1ffaaa874ee2066b3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "be386e1639549e84c97742c5", "postgresql": "be386e1639549e84c97742c5", "snowflake": "8c43a62af28ed0ed164b472b", @@ -7471,8 +7471,8 @@ "databricks": "733b04338829c5844270d25e", "duckdb": "733b04338829c5844270d25e", "generic": "733b04338829c5844270d25e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "733b04338829c5844270d25e", +"motherduck": "733b04338829c5844270d25e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "733b04338829c5844270d25e", "postgresql": "733b04338829c5844270d25e", "snowflake": "733b04338829c5844270d25e", @@ -7483,17 +7483,17 @@ "type", { "DuckDB": "5abf4ec799a2ec32fb10da7e", -"None": "5abf4ec799a2ec32fb10da7e", +"None": "de89632e277dbc8c97115419", "bigquery": "5abf4ec799a2ec32fb10da7e", -"databricks": "5abf4ec799a2ec32fb10da7e", +"databricks": "de89632e277dbc8c97115419", "duckdb": "5abf4ec799a2ec32fb10da7e", -"generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", +"generic": "de89632e277dbc8c97115419", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5abf4ec799a2ec32fb10da7e", "postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "a5656d70e208254d1d3e9b4f", -"tsql": "5abf4ec799a2ec32fb10da7e" +"tsql": "de89632e277dbc8c97115419" } ], [ @@ -7501,14 +7501,14 @@ { "DuckDB": "08736485547ba339930697e9", "None": "08736485547ba339930697e9", -"bigquery": "08736485547ba339930697e9", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "08736485547ba339930697e9", "duckdb": "08736485547ba339930697e9", "generic": "08736485547ba339930697e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "08736485547ba339930697e9", -"postgres": "08736485547ba339930697e9", -"postgresql": "08736485547ba339930697e9", +"motherduck": "08736485547ba339930697e9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eecd452b4f5f3f4133d0bd0a", +"postgresql": "eecd452b4f5f3f4133d0bd0a", "snowflake": "08736485547ba339930697e9", "tsql": "08736485547ba339930697e9" } @@ -7518,14 +7518,14 @@ { "DuckDB": "7cd31289a5b99b5a5e24492d", "None": "7cd31289a5b99b5a5e24492d", -"bigquery": "7cd31289a5b99b5a5e24492d", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "7cd31289a5b99b5a5e24492d", "duckdb": "7cd31289a5b99b5a5e24492d", "generic": "7cd31289a5b99b5a5e24492d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7cd31289a5b99b5a5e24492d", -"postgres": "7cd31289a5b99b5a5e24492d", -"postgresql": "7cd31289a5b99b5a5e24492d", +"motherduck": "7cd31289a5b99b5a5e24492d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "c5bdaf88df7ef3d9ae693106", +"postgresql": "c5bdaf88df7ef3d9ae693106", "snowflake": "7cd31289a5b99b5a5e24492d", "tsql": "7cd31289a5b99b5a5e24492d" } @@ -7539,8 +7539,8 @@ "databricks": "a9d9e03f8e981cec9dca7694", "duckdb": "a9d9e03f8e981cec9dca7694", "generic": "a9d9e03f8e981cec9dca7694", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a9d9e03f8e981cec9dca7694", +"motherduck": "a9d9e03f8e981cec9dca7694", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a9d9e03f8e981cec9dca7694", "postgresql": "a9d9e03f8e981cec9dca7694", "snowflake": "a9d9e03f8e981cec9dca7694", @@ -7556,10 +7556,10 @@ "databricks": "8b8d5f75ba6dec68b4cebc6b", "duckdb": "8b8d5f75ba6dec68b4cebc6b", "generic": "8b8d5f75ba6dec68b4cebc6b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8b8d5f75ba6dec68b4cebc6b", -"postgres": "8b8d5f75ba6dec68b4cebc6b", -"postgresql": "8b8d5f75ba6dec68b4cebc6b", +"motherduck": "8b8d5f75ba6dec68b4cebc6b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "7914189ff18b0e70ddf7d042", +"postgresql": "7914189ff18b0e70ddf7d042", "snowflake": "8b8d5f75ba6dec68b4cebc6b", "tsql": "8b8d5f75ba6dec68b4cebc6b" } @@ -7573,8 +7573,8 @@ "databricks": "3959952046272deb40567543", "duckdb": "3959952046272deb40567543", "generic": "3959952046272deb40567543", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3959952046272deb40567543", +"motherduck": "3959952046272deb40567543", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3959952046272deb40567543", "postgresql": "3959952046272deb40567543", "snowflake": "3959952046272deb40567543", @@ -7590,8 +7590,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "c5d56d00f80f43bfec07a7c2", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "c5d56d00f80f43bfec07a7c2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -7607,8 +7607,8 @@ "databricks": "251aba3fef503ce64556c701", "duckdb": "251aba3fef503ce64556c701", "generic": "251aba3fef503ce64556c701", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "251aba3fef503ce64556c701", +"motherduck": "251aba3fef503ce64556c701", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "251aba3fef503ce64556c701", "postgresql": "251aba3fef503ce64556c701", "snowflake": "c50a316d091c821866e4bfba", @@ -7624,8 +7624,8 @@ "databricks": "5855bf076c2cc936300b1e0a", "duckdb": "5855bf076c2cc936300b1e0a", "generic": "5855bf076c2cc936300b1e0a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5855bf076c2cc936300b1e0a", +"motherduck": "5855bf076c2cc936300b1e0a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5855bf076c2cc936300b1e0a", "postgresql": "5855bf076c2cc936300b1e0a", "snowflake": "5855bf076c2cc936300b1e0a", @@ -7636,17 +7636,17 @@ "type", { "DuckDB": "f2ed52f6bf46b4db9343551c", -"None": "f2ed52f6bf46b4db9343551c", -"bigquery": "f10bdd4d40eb495cbcecd31d", -"databricks": "f2ed52f6bf46b4db9343551c", +"None": "3f998a9ab68d8b2514840489", +"bigquery": "cc809c2a2f4e06379d6e4fe5", +"databricks": "3f998a9ab68d8b2514840489", "duckdb": "f2ed52f6bf46b4db9343551c", -"generic": "f2ed52f6bf46b4db9343551c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f2ed52f6bf46b4db9343551c", -"postgres": "f2ed52f6bf46b4db9343551c", -"postgresql": "f2ed52f6bf46b4db9343551c", +"generic": "3f998a9ab68d8b2514840489", +"motherduck": "f2ed52f6bf46b4db9343551c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "7ce41cc5375b618de22b6a4e", +"postgresql": "7ce41cc5375b618de22b6a4e", "snowflake": "f2ed52f6bf46b4db9343551c", -"tsql": "f2ed52f6bf46b4db9343551c" +"tsql": "3f998a9ab68d8b2514840489" } ], [ @@ -7658,10 +7658,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -7675,8 +7675,8 @@ "databricks": "42f8fe02ce664d09ff39167c", "duckdb": "42f8fe02ce664d09ff39167c", "generic": "42f8fe02ce664d09ff39167c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "42f8fe02ce664d09ff39167c", +"motherduck": "42f8fe02ce664d09ff39167c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "42f8fe02ce664d09ff39167c", "postgresql": "42f8fe02ce664d09ff39167c", "snowflake": "42f8fe02ce664d09ff39167c", @@ -7687,17 +7687,17 @@ "type", { "DuckDB": "4ebb6333caac069be16c795d", -"None": "4ebb6333caac069be16c795d", -"bigquery": "4ebb6333caac069be16c795d", -"databricks": "4ebb6333caac069be16c795d", +"None": "d5ce089ec505733f59838ffd", +"bigquery": "d5ce089ec505733f59838ffd", +"databricks": "d5ce089ec505733f59838ffd", "duckdb": "4ebb6333caac069be16c795d", -"generic": "4ebb6333caac069be16c795d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4ebb6333caac069be16c795d", +"generic": "d5ce089ec505733f59838ffd", +"motherduck": "4ebb6333caac069be16c795d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4ebb6333caac069be16c795d", "postgresql": "4ebb6333caac069be16c795d", "snowflake": "4ebb6333caac069be16c795d", -"tsql": "4ebb6333caac069be16c795d" +"tsql": "d5ce089ec505733f59838ffd" } ], [ @@ -7709,8 +7709,8 @@ "databricks": "c844c96e1e3ffc72d5f90df9", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "c844c96e1e3ffc72d5f90df9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "28eb0d6de9724959ce5ba43e", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c844c96e1e3ffc72d5f90df9", "postgresql": "c844c96e1e3ffc72d5f90df9", "snowflake": "c844c96e1e3ffc72d5f90df9", @@ -7726,8 +7726,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -7743,8 +7743,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "8441d00030df06ad6a5534d3", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "8441d00030df06ad6a5534d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -7760,8 +7760,8 @@ "databricks": "3915f3f73328f0838497b2d5", "duckdb": "3915f3f73328f0838497b2d5", "generic": "3915f3f73328f0838497b2d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3915f3f73328f0838497b2d5", +"motherduck": "3915f3f73328f0838497b2d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3915f3f73328f0838497b2d5", "postgresql": "3915f3f73328f0838497b2d5", "snowflake": "f43dac38f34a1c0618a3f812", @@ -7777,8 +7777,8 @@ "databricks": "52e79b501b430a4c2b097344", "duckdb": "52e79b501b430a4c2b097344", "generic": "52e79b501b430a4c2b097344", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "52e79b501b430a4c2b097344", +"motherduck": "52e79b501b430a4c2b097344", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "52e79b501b430a4c2b097344", "postgresql": "52e79b501b430a4c2b097344", "snowflake": "52e79b501b430a4c2b097344", @@ -7789,17 +7789,17 @@ "type", { "DuckDB": "13f1401e7cd410600a4c9485", -"None": "13f1401e7cd410600a4c9485", -"bigquery": "74a30f6aa9def0b58afc616c", -"databricks": "13f1401e7cd410600a4c9485", +"None": "75c45736873ac5c99a62bc20", +"bigquery": "a686bb6db17ab079cfc79224", +"databricks": "75c45736873ac5c99a62bc20", "duckdb": "13f1401e7cd410600a4c9485", -"generic": "13f1401e7cd410600a4c9485", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "13f1401e7cd410600a4c9485", +"generic": "75c45736873ac5c99a62bc20", +"motherduck": "13f1401e7cd410600a4c9485", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "13f1401e7cd410600a4c9485", "postgresql": "13f1401e7cd410600a4c9485", "snowflake": "9b5f44707b5f4764b82741be", -"tsql": "13f1401e7cd410600a4c9485" +"tsql": "75c45736873ac5c99a62bc20" } ], [ @@ -7807,14 +7807,14 @@ { "DuckDB": "d2c97d221599d038d9875873", "None": "d2c97d221599d038d9875873", -"bigquery": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", "databricks": "d2c97d221599d038d9875873", "duckdb": "d2c97d221599d038d9875873", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "d2c97d221599d038d9875873", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -7828,8 +7828,8 @@ "databricks": "802f1c1fcb97ddd5679172d2", "duckdb": "802f1c1fcb97ddd5679172d2", "generic": "802f1c1fcb97ddd5679172d2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "802f1c1fcb97ddd5679172d2", +"motherduck": "802f1c1fcb97ddd5679172d2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "802f1c1fcb97ddd5679172d2", "postgresql": "802f1c1fcb97ddd5679172d2", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -7845,8 +7845,8 @@ "databricks": "60a23b7dcae6c79f4de83068", "duckdb": "60a23b7dcae6c79f4de83068", "generic": "60a23b7dcae6c79f4de83068", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "60a23b7dcae6c79f4de83068", +"motherduck": "60a23b7dcae6c79f4de83068", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "60a23b7dcae6c79f4de83068", "postgresql": "60a23b7dcae6c79f4de83068", "snowflake": "60a23b7dcae6c79f4de83068", @@ -7858,14 +7858,14 @@ { "DuckDB": "4b356542044f1267fcfc487a", "None": "4b356542044f1267fcfc487a", -"bigquery": "4b356542044f1267fcfc487a", +"bigquery": "a5656d70e208254d1d3e9b4f", "databricks": "4b356542044f1267fcfc487a", "duckdb": "4b356542044f1267fcfc487a", "generic": "4b356542044f1267fcfc487a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4b356542044f1267fcfc487a", -"postgres": "4b356542044f1267fcfc487a", -"postgresql": "4b356542044f1267fcfc487a", +"motherduck": "4b356542044f1267fcfc487a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a5656d70e208254d1d3e9b4f", +"postgresql": "a5656d70e208254d1d3e9b4f", "snowflake": "4b356542044f1267fcfc487a", "tsql": "4b356542044f1267fcfc487a" } @@ -7879,8 +7879,8 @@ "databricks": "3315bb12afea7b182498ce28", "duckdb": "3315bb12afea7b182498ce28", "generic": "3315bb12afea7b182498ce28", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3315bb12afea7b182498ce28", +"motherduck": "3315bb12afea7b182498ce28", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3315bb12afea7b182498ce28", "postgresql": "3315bb12afea7b182498ce28", "snowflake": "3315bb12afea7b182498ce28", @@ -7896,8 +7896,8 @@ "databricks": "916f1a306af797bd328aec64", "duckdb": "2844656bba2e199281ab8d9b", "generic": "2844656bba2e199281ab8d9b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "916f1a306af797bd328aec64", +"motherduck": "2844656bba2e199281ab8d9b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2844656bba2e199281ab8d9b", "postgresql": "2844656bba2e199281ab8d9b", "snowflake": "2844656bba2e199281ab8d9b", @@ -7913,8 +7913,8 @@ "databricks": "e62af34c2d31bc9ab880629e", "duckdb": "8a7aa7fa75696327320e0add", "generic": "8a7aa7fa75696327320e0add", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e62af34c2d31bc9ab880629e", +"motherduck": "8a7aa7fa75696327320e0add", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8a7aa7fa75696327320e0add", "postgresql": "8a7aa7fa75696327320e0add", "snowflake": "8a7aa7fa75696327320e0add", @@ -7930,11 +7930,11 @@ "databricks": "cbea30a905a72d3b17dc7211", "duckdb": "cbea30a905a72d3b17dc7211", "generic": "cbea30a905a72d3b17dc7211", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cbea30a905a72d3b17dc7211", +"motherduck": "cbea30a905a72d3b17dc7211", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cbea30a905a72d3b17dc7211", "postgresql": "cbea30a905a72d3b17dc7211", -"snowflake": "cbea30a905a72d3b17dc7211", +"snowflake": "7d597ede6f7cf27affdde1b0", "tsql": "cbea30a905a72d3b17dc7211" } ], @@ -7947,8 +7947,8 @@ "databricks": "f15c56475abfc73488abe63b", "duckdb": "f15c56475abfc73488abe63b", "generic": "f15c56475abfc73488abe63b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f15c56475abfc73488abe63b", +"motherduck": "f15c56475abfc73488abe63b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f15c56475abfc73488abe63b", "postgresql": "f15c56475abfc73488abe63b", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -7964,8 +7964,8 @@ "databricks": "e8b6e0bd2ded7b9eec6209e4", "duckdb": "e8b6e0bd2ded7b9eec6209e4", "generic": "e8b6e0bd2ded7b9eec6209e4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e8b6e0bd2ded7b9eec6209e4", +"motherduck": "e8b6e0bd2ded7b9eec6209e4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8b6e0bd2ded7b9eec6209e4", "postgresql": "e8b6e0bd2ded7b9eec6209e4", "snowflake": "e8b6e0bd2ded7b9eec6209e4", @@ -7981,8 +7981,8 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "1d8b945fd793ecdcacb90c21", "generic": "1d8b945fd793ecdcacb90c21", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1d8b945fd793ecdcacb90c21", +"motherduck": "1d8b945fd793ecdcacb90c21", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3efe8bb57c98fcbe74096b3c", "postgresql": "3efe8bb57c98fcbe74096b3c", "snowflake": "1d8b945fd793ecdcacb90c21", @@ -7998,10 +7998,10 @@ "databricks": "4e10d2f9eb8994ead08d1761", "duckdb": "4e10d2f9eb8994ead08d1761", "generic": "4e10d2f9eb8994ead08d1761", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4e10d2f9eb8994ead08d1761", -"postgres": "4e10d2f9eb8994ead08d1761", -"postgresql": "4e10d2f9eb8994ead08d1761", +"motherduck": "4e10d2f9eb8994ead08d1761", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f7f38c204fc2a5b7e7986a31", +"postgresql": "f7f38c204fc2a5b7e7986a31", "snowflake": "4e10d2f9eb8994ead08d1761", "tsql": "4e10d2f9eb8994ead08d1761" } @@ -8015,8 +8015,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -8032,8 +8032,8 @@ "databricks": "46ec3e19e05a6cb29854ccac", "duckdb": "35e216b6921bf843994f2eea", "generic": "46ec3e19e05a6cb29854ccac", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "46ec3e19e05a6cb29854ccac", +"motherduck": "35e216b6921bf843994f2eea", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "46ec3e19e05a6cb29854ccac", "postgresql": "46ec3e19e05a6cb29854ccac", "snowflake": "46ec3e19e05a6cb29854ccac", @@ -8044,17 +8044,17 @@ "type", { "DuckDB": "7515c0db413239044adef879", -"None": "7515c0db413239044adef879", -"bigquery": "f276e907770196606577c932", -"databricks": "7515c0db413239044adef879", +"None": "d4b89e61a66aeb076db92954", +"bigquery": "bb92c01c64d1a2d32abb67b5", +"databricks": "d4b89e61a66aeb076db92954", "duckdb": "7515c0db413239044adef879", -"generic": "7515c0db413239044adef879", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7515c0db413239044adef879", +"generic": "d4b89e61a66aeb076db92954", +"motherduck": "7515c0db413239044adef879", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7515c0db413239044adef879", "postgresql": "7515c0db413239044adef879", "snowflake": "67b5874a2c569226c490211f", -"tsql": "7515c0db413239044adef879" +"tsql": "d4b89e61a66aeb076db92954" } ], [ @@ -8066,8 +8066,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -8083,8 +8083,8 @@ "databricks": "4662a1758442ce44b830269f", "duckdb": "4662a1758442ce44b830269f", "generic": "4662a1758442ce44b830269f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4662a1758442ce44b830269f", +"motherduck": "4662a1758442ce44b830269f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4662a1758442ce44b830269f", "postgresql": "4662a1758442ce44b830269f", "snowflake": "4662a1758442ce44b830269f", @@ -8095,15 +8095,15 @@ "type", { "DuckDB": "a55ce7977ac874a3b204217e", -"None": "86b982a98982cd844f498c36", -"bigquery": "86b982a98982cd844f498c36", -"databricks": "86b982a98982cd844f498c36", +"None": "a13763a505b15f311cd22d08", +"bigquery": "a13763a505b15f311cd22d08", +"databricks": "a13763a505b15f311cd22d08", "duckdb": "a55ce7977ac874a3b204217e", -"generic": "86b982a98982cd844f498c36", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "a55ce7977ac874a3b204217e", -"postgresql": "a55ce7977ac874a3b204217e", +"generic": "a13763a505b15f311cd22d08", +"motherduck": "a55ce7977ac874a3b204217e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a13763a505b15f311cd22d08", +"postgresql": "a13763a505b15f311cd22d08", "snowflake": "5a4429eb67014c1c8f9e10d4", "tsql": "a13763a505b15f311cd22d08" } @@ -8113,12 +8113,12 @@ { "DuckDB": "62368fc15cefd5807807b209", "None": "62368fc15cefd5807807b209", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "62368fc15cefd5807807b209", "duckdb": "62368fc15cefd5807807b209", "generic": "62368fc15cefd5807807b209", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "62368fc15cefd5807807b209", +"motherduck": "62368fc15cefd5807807b209", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "62368fc15cefd5807807b209", "postgresql": "62368fc15cefd5807807b209", "snowflake": "62368fc15cefd5807807b209", @@ -8134,10 +8134,10 @@ "databricks": "bbb97828cd28c64282709796", "duckdb": "bbb97828cd28c64282709796", "generic": "bbb97828cd28c64282709796", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "bbb97828cd28c64282709796", -"postgres": "bbb97828cd28c64282709796", -"postgresql": "bbb97828cd28c64282709796", +"motherduck": "bbb97828cd28c64282709796", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "b210f8eb26c37b422f786c6b", +"postgresql": "b210f8eb26c37b422f786c6b", "snowflake": "bbb97828cd28c64282709796", "tsql": "bbb97828cd28c64282709796" } @@ -8151,8 +8151,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -8164,14 +8164,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -8180,15 +8180,15 @@ "type", { "DuckDB": "02861a11fe2b8f1a7351cb12", -"None": "3abc5e3c14192017bfd1ead5", +"None": "f2c7751cca55dc87c36b6fc2", "bigquery": "f2c7751cca55dc87c36b6fc2", "databricks": "f2c7751cca55dc87c36b6fc2", "duckdb": "02861a11fe2b8f1a7351cb12", -"generic": "3abc5e3c14192017bfd1ead5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f2c7751cca55dc87c36b6fc2", -"postgres": "35efca2fc5df9bbd4013257a", -"postgresql": "35efca2fc5df9bbd4013257a", +"generic": "f2c7751cca55dc87c36b6fc2", +"motherduck": "02861a11fe2b8f1a7351cb12", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f2c7751cca55dc87c36b6fc2", +"postgresql": "f2c7751cca55dc87c36b6fc2", "snowflake": "5b65e3054ea3260a0a6dd837", "tsql": "f2c7751cca55dc87c36b6fc2" } @@ -8202,8 +8202,8 @@ "databricks": "efe77000c8cb77e8bcc49328", "duckdb": "d1a9a884331f069d89b0935f", "generic": "d1a9a884331f069d89b0935f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "efe77000c8cb77e8bcc49328", +"motherduck": "d1a9a884331f069d89b0935f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d1a9a884331f069d89b0935f", "postgresql": "d1a9a884331f069d89b0935f", "snowflake": "d1a9a884331f069d89b0935f", @@ -8219,8 +8219,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -8236,10 +8236,10 @@ "databricks": "bce60580ef3a1dc4ce569fff", "duckdb": "bce60580ef3a1dc4ce569fff", "generic": "bce60580ef3a1dc4ce569fff", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "bce60580ef3a1dc4ce569fff", -"postgres": "bce60580ef3a1dc4ce569fff", -"postgresql": "bce60580ef3a1dc4ce569fff", +"motherduck": "bce60580ef3a1dc4ce569fff", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eee236ea1427bdddbaf088ac", +"postgresql": "eee236ea1427bdddbaf088ac", "snowflake": "bce60580ef3a1dc4ce569fff", "tsql": "bce60580ef3a1dc4ce569fff" } @@ -8249,14 +8249,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -8270,8 +8270,8 @@ "databricks": "cc33965a669608ec39e8c246", "duckdb": "cc33965a669608ec39e8c246", "generic": "cc33965a669608ec39e8c246", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cc33965a669608ec39e8c246", +"motherduck": "cc33965a669608ec39e8c246", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cc33965a669608ec39e8c246", "postgresql": "cc33965a669608ec39e8c246", "snowflake": "cc33965a669608ec39e8c246", @@ -8287,10 +8287,10 @@ "databricks": "4381456d770bb42050076d00", "duckdb": "4381456d770bb42050076d00", "generic": "4381456d770bb42050076d00", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4381456d770bb42050076d00", -"postgres": "4381456d770bb42050076d00", -"postgresql": "4381456d770bb42050076d00", +"motherduck": "4381456d770bb42050076d00", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "1f89b04f39a23f492cb6e5eb", +"postgresql": "1f89b04f39a23f492cb6e5eb", "snowflake": "4381456d770bb42050076d00", "tsql": "4381456d770bb42050076d00" } @@ -8304,8 +8304,8 @@ "databricks": "a34c63be87b77d81239d0b4b", "duckdb": "a34c63be87b77d81239d0b4b", "generic": "a34c63be87b77d81239d0b4b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a34c63be87b77d81239d0b4b", +"motherduck": "a34c63be87b77d81239d0b4b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a34c63be87b77d81239d0b4b", "postgresql": "a34c63be87b77d81239d0b4b", "snowflake": "a34c63be87b77d81239d0b4b", @@ -8321,8 +8321,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -8338,8 +8338,8 @@ "databricks": "0703bf71a54942bdaa28406e", "duckdb": "0703bf71a54942bdaa28406e", "generic": "0703bf71a54942bdaa28406e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0703bf71a54942bdaa28406e", +"motherduck": "0703bf71a54942bdaa28406e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0703bf71a54942bdaa28406e", "postgresql": "0703bf71a54942bdaa28406e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -8352,11 +8352,11 @@ "DuckDB": "0d58e20cd83f047b3b85cd1c", "None": "0d58e20cd83f047b3b85cd1c", "bigquery": "0d58e20cd83f047b3b85cd1c", -"databricks": "9f2957c784cb1f6b640c10f7", +"databricks": "0d58e20cd83f047b3b85cd1c", "duckdb": "0d58e20cd83f047b3b85cd1c", "generic": "0d58e20cd83f047b3b85cd1c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9f2957c784cb1f6b640c10f7", +"motherduck": "0d58e20cd83f047b3b85cd1c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0d58e20cd83f047b3b85cd1c", "postgresql": "0d58e20cd83f047b3b85cd1c", "snowflake": "0d58e20cd83f047b3b85cd1c", @@ -8368,14 +8368,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -8389,8 +8389,8 @@ "databricks": "dba9493579be12efd69318ac", "duckdb": "63e20906fe3504356e04d05e", "generic": "dba9493579be12efd69318ac", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "63e20906fe3504356e04d05e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "63e20906fe3504356e04d05e", "postgresql": "63e20906fe3504356e04d05e", "snowflake": "30696690153e91e7ae197982", @@ -8406,8 +8406,8 @@ "databricks": "7914189ff18b0e70ddf7d042", "duckdb": "7914189ff18b0e70ddf7d042", "generic": "7914189ff18b0e70ddf7d042", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7914189ff18b0e70ddf7d042", +"motherduck": "7914189ff18b0e70ddf7d042", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7914189ff18b0e70ddf7d042", "postgresql": "7914189ff18b0e70ddf7d042", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -8418,17 +8418,17 @@ "type", { "DuckDB": "919b7ec6a7b49d8527b784cd", -"None": "919b7ec6a7b49d8527b784cd", -"bigquery": "204206d1d1eecf007966cc5b", -"databricks": "e3bc1b8bad22d8104417b00f", +"None": "558da38ec4d9d5d6c72f60cf", +"bigquery": "c50a316d091c821866e4bfba", +"databricks": "558da38ec4d9d5d6c72f60cf", "duckdb": "919b7ec6a7b49d8527b784cd", -"generic": "919b7ec6a7b49d8527b784cd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "919b7ec6a7b49d8527b784cd", -"postgres": "a3b6b25265be330ec52a3322", -"postgresql": "a3b6b25265be330ec52a3322", +"generic": "558da38ec4d9d5d6c72f60cf", +"motherduck": "919b7ec6a7b49d8527b784cd", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "558da38ec4d9d5d6c72f60cf", +"postgresql": "558da38ec4d9d5d6c72f60cf", "snowflake": "919b7ec6a7b49d8527b784cd", -"tsql": "919b7ec6a7b49d8527b784cd" +"tsql": "558da38ec4d9d5d6c72f60cf" } ], [ @@ -8440,8 +8440,8 @@ "databricks": "42cd2b5892468e185781348b", "duckdb": "42cd2b5892468e185781348b", "generic": "42cd2b5892468e185781348b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "42cd2b5892468e185781348b", +"motherduck": "42cd2b5892468e185781348b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "42cd2b5892468e185781348b", "postgresql": "42cd2b5892468e185781348b", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -8457,8 +8457,8 @@ "databricks": "46ec3e19e05a6cb29854ccac", "duckdb": "35e216b6921bf843994f2eea", "generic": "46ec3e19e05a6cb29854ccac", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "46ec3e19e05a6cb29854ccac", +"motherduck": "35e216b6921bf843994f2eea", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "46ec3e19e05a6cb29854ccac", "postgresql": "46ec3e19e05a6cb29854ccac", "snowflake": "46ec3e19e05a6cb29854ccac", @@ -8474,8 +8474,8 @@ "databricks": "eed0645c1e86fa1a6e35ccaa", "duckdb": "eed0645c1e86fa1a6e35ccaa", "generic": "eed0645c1e86fa1a6e35ccaa", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "eed0645c1e86fa1a6e35ccaa", +"motherduck": "eed0645c1e86fa1a6e35ccaa", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "eed0645c1e86fa1a6e35ccaa", "postgresql": "eed0645c1e86fa1a6e35ccaa", "snowflake": "97a20344d811fb77c7690863", @@ -8491,8 +8491,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -8508,8 +8508,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -8522,11 +8522,11 @@ "DuckDB": "0f3d33062aebbc5edec7b64f", "None": "0f3d33062aebbc5edec7b64f", "bigquery": "0f3d33062aebbc5edec7b64f", -"databricks": "544d1979b70121c2f5770b6a", +"databricks": "0f3d33062aebbc5edec7b64f", "duckdb": "0f3d33062aebbc5edec7b64f", "generic": "0f3d33062aebbc5edec7b64f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "544d1979b70121c2f5770b6a", +"motherduck": "0f3d33062aebbc5edec7b64f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0f3d33062aebbc5edec7b64f", "postgresql": "0f3d33062aebbc5edec7b64f", "snowflake": "0f3d33062aebbc5edec7b64f", @@ -8542,8 +8542,8 @@ "databricks": "b2c9b6ebca6c097f3caa0aa8", "duckdb": "b2c9b6ebca6c097f3caa0aa8", "generic": "b2c9b6ebca6c097f3caa0aa8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b2c9b6ebca6c097f3caa0aa8", +"motherduck": "b2c9b6ebca6c097f3caa0aa8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b2c9b6ebca6c097f3caa0aa8", "postgresql": "b2c9b6ebca6c097f3caa0aa8", "snowflake": "b2c9b6ebca6c097f3caa0aa8", @@ -8559,8 +8559,8 @@ "databricks": "c21a08c5ec73e14b4d409300", "duckdb": "c21a08c5ec73e14b4d409300", "generic": "c21a08c5ec73e14b4d409300", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c21a08c5ec73e14b4d409300", +"motherduck": "c21a08c5ec73e14b4d409300", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c21a08c5ec73e14b4d409300", "postgresql": "c21a08c5ec73e14b4d409300", "snowflake": "c21a08c5ec73e14b4d409300", @@ -8572,14 +8572,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -8593,8 +8593,8 @@ "databricks": "88582da8542d7d1abf567520", "duckdb": "88582da8542d7d1abf567520", "generic": "88582da8542d7d1abf567520", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "88582da8542d7d1abf567520", +"motherduck": "88582da8542d7d1abf567520", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "88582da8542d7d1abf567520", "postgresql": "88582da8542d7d1abf567520", "snowflake": "88582da8542d7d1abf567520", @@ -8610,8 +8610,8 @@ "databricks": "8a10388471810a2bd58f7686", "duckdb": "8a10388471810a2bd58f7686", "generic": "8a10388471810a2bd58f7686", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8a10388471810a2bd58f7686", +"motherduck": "8a10388471810a2bd58f7686", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8a10388471810a2bd58f7686", "postgresql": "8a10388471810a2bd58f7686", "snowflake": "8a10388471810a2bd58f7686", @@ -8627,8 +8627,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -8644,10 +8644,10 @@ "databricks": "64fc778308b798a730b1d5c9", "duckdb": "64fc778308b798a730b1d5c9", "generic": "64fc778308b798a730b1d5c9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "64fc778308b798a730b1d5c9", -"postgres": "64fc778308b798a730b1d5c9", -"postgresql": "64fc778308b798a730b1d5c9", +"motherduck": "64fc778308b798a730b1d5c9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "c8ca7a940ad228dd836cad6f", +"postgresql": "c8ca7a940ad228dd836cad6f", "snowflake": "64fc778308b798a730b1d5c9", "tsql": "64fc778308b798a730b1d5c9" } @@ -8661,8 +8661,8 @@ "databricks": "679a90349a55ba7765c07664", "duckdb": "679a90349a55ba7765c07664", "generic": "679a90349a55ba7765c07664", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "679a90349a55ba7765c07664", +"motherduck": "679a90349a55ba7765c07664", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "679a90349a55ba7765c07664", "postgresql": "679a90349a55ba7765c07664", "snowflake": "679a90349a55ba7765c07664", @@ -8678,8 +8678,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -8690,30 +8690,30 @@ "type", { "DuckDB": "3147a9e06daa6de4a4df5abc", -"None": "3147a9e06daa6de4a4df5abc", -"bigquery": "f276e907770196606577c932", -"databricks": "3147a9e06daa6de4a4df5abc", +"None": "da0625706f12b764a6912278", +"bigquery": "b0477b36767a62145aa9158c", +"databricks": "da0625706f12b764a6912278", "duckdb": "3147a9e06daa6de4a4df5abc", -"generic": "3147a9e06daa6de4a4df5abc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3147a9e06daa6de4a4df5abc", +"generic": "da0625706f12b764a6912278", +"motherduck": "3147a9e06daa6de4a4df5abc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3147a9e06daa6de4a4df5abc", "postgresql": "3147a9e06daa6de4a4df5abc", "snowflake": "67b5874a2c569226c490211f", -"tsql": "3147a9e06daa6de4a4df5abc" +"tsql": "da0625706f12b764a6912278" } ], [ "type", { "DuckDB": "ff99ba717583eafc6fdd9442", -"None": "a915140f475538632ca59017", -"bigquery": "a915140f475538632ca59017", -"databricks": "a915140f475538632ca59017", +"None": "3b16d8eb223ae1333ecbc2bf", +"bigquery": "3b16d8eb223ae1333ecbc2bf", +"databricks": "3b16d8eb223ae1333ecbc2bf", "duckdb": "ff99ba717583eafc6fdd9442", -"generic": "a915140f475538632ca59017", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"generic": "3b16d8eb223ae1333ecbc2bf", +"motherduck": "ff99ba717583eafc6fdd9442", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "39ac50273811909ae35979b7", "postgresql": "39ac50273811909ae35979b7", "snowflake": "ca443b97e784bced05b62f0b", @@ -8729,8 +8729,8 @@ "databricks": "e7683084f9cefaf3748cf526", "duckdb": "e7683084f9cefaf3748cf526", "generic": "e7683084f9cefaf3748cf526", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e7683084f9cefaf3748cf526", +"motherduck": "e7683084f9cefaf3748cf526", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e7683084f9cefaf3748cf526", "postgresql": "e7683084f9cefaf3748cf526", "snowflake": "e7683084f9cefaf3748cf526", @@ -8746,8 +8746,8 @@ "databricks": "9626d393c137a37008bb4b89", "duckdb": "9626d393c137a37008bb4b89", "generic": "9626d393c137a37008bb4b89", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9626d393c137a37008bb4b89", +"motherduck": "9626d393c137a37008bb4b89", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9626d393c137a37008bb4b89", "postgresql": "9626d393c137a37008bb4b89", "snowflake": "9626d393c137a37008bb4b89", @@ -8763,10 +8763,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -8780,8 +8780,8 @@ "databricks": "4e47cae1f2f84f5e523dc43f", "duckdb": "4e47cae1f2f84f5e523dc43f", "generic": "4e47cae1f2f84f5e523dc43f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4e47cae1f2f84f5e523dc43f", +"motherduck": "4e47cae1f2f84f5e523dc43f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4e47cae1f2f84f5e523dc43f", "postgresql": "4e47cae1f2f84f5e523dc43f", "snowflake": "4e47cae1f2f84f5e523dc43f", @@ -8797,8 +8797,8 @@ "databricks": "8fe65454f387031aa6231faf", "duckdb": "8fe65454f387031aa6231faf", "generic": "8fe65454f387031aa6231faf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8fe65454f387031aa6231faf", +"motherduck": "8fe65454f387031aa6231faf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8fe65454f387031aa6231faf", "postgresql": "8fe65454f387031aa6231faf", "snowflake": "8fe65454f387031aa6231faf", @@ -8809,17 +8809,17 @@ "type", { "DuckDB": "a428302e4848ffe877284c84", -"None": "a428302e4848ffe877284c84", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "a428302e4848ffe877284c84", +"None": "c9b810639795a7bfab91b98d", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "c9b810639795a7bfab91b98d", "duckdb": "a428302e4848ffe877284c84", -"generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"generic": "c9b810639795a7bfab91b98d", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "a428302e4848ffe877284c84" +"tsql": "c9b810639795a7bfab91b98d" } ], [ @@ -8831,8 +8831,8 @@ "databricks": "c844c96e1e3ffc72d5f90df9", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "c844c96e1e3ffc72d5f90df9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "28eb0d6de9724959ce5ba43e", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c844c96e1e3ffc72d5f90df9", "postgresql": "c844c96e1e3ffc72d5f90df9", "snowflake": "c844c96e1e3ffc72d5f90df9", @@ -8848,8 +8848,8 @@ "databricks": "e8b6e0bd2ded7b9eec6209e4", "duckdb": "e8b6e0bd2ded7b9eec6209e4", "generic": "e8b6e0bd2ded7b9eec6209e4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e8b6e0bd2ded7b9eec6209e4", +"motherduck": "e8b6e0bd2ded7b9eec6209e4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8b6e0bd2ded7b9eec6209e4", "postgresql": "e8b6e0bd2ded7b9eec6209e4", "snowflake": "e8b6e0bd2ded7b9eec6209e4", @@ -8861,12 +8861,12 @@ { "DuckDB": "d41d40c68507f4d02e348833", "None": "d41d40c68507f4d02e348833", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "d41d40c68507f4d02e348833", "duckdb": "d41d40c68507f4d02e348833", "generic": "d41d40c68507f4d02e348833", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d41d40c68507f4d02e348833", +"motherduck": "d41d40c68507f4d02e348833", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d41d40c68507f4d02e348833", "postgresql": "d41d40c68507f4d02e348833", "snowflake": "d41d40c68507f4d02e348833", @@ -8878,14 +8878,14 @@ { "DuckDB": "18db5afe2c1e80d1ee652b54", "None": "18db5afe2c1e80d1ee652b54", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "18db5afe2c1e80d1ee652b54", "duckdb": "18db5afe2c1e80d1ee652b54", "generic": "18db5afe2c1e80d1ee652b54", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "18db5afe2c1e80d1ee652b54", -"postgres": "18db5afe2c1e80d1ee652b54", -"postgresql": "18db5afe2c1e80d1ee652b54", +"motherduck": "18db5afe2c1e80d1ee652b54", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "47d64a5994d42a2b577166ea", +"postgresql": "47d64a5994d42a2b577166ea", "snowflake": "18db5afe2c1e80d1ee652b54", "tsql": "18db5afe2c1e80d1ee652b54" } @@ -8899,8 +8899,8 @@ "databricks": "29685ad61061d232d5b44f98", "duckdb": "fbb8dada51c532716b2cbf9f", "generic": "29685ad61061d232d5b44f98", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "fbb8dada51c532716b2cbf9f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fbb8dada51c532716b2cbf9f", "postgresql": "fbb8dada51c532716b2cbf9f", "snowflake": "3d54d99fa15cb697878997d5", @@ -8916,8 +8916,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -8933,8 +8933,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -8945,17 +8945,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -8967,10 +8967,10 @@ "databricks": "64fc778308b798a730b1d5c9", "duckdb": "64fc778308b798a730b1d5c9", "generic": "64fc778308b798a730b1d5c9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "64fc778308b798a730b1d5c9", -"postgres": "64fc778308b798a730b1d5c9", -"postgresql": "64fc778308b798a730b1d5c9", +"motherduck": "64fc778308b798a730b1d5c9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "c8ca7a940ad228dd836cad6f", +"postgresql": "c8ca7a940ad228dd836cad6f", "snowflake": "64fc778308b798a730b1d5c9", "tsql": "64fc778308b798a730b1d5c9" } @@ -8984,8 +8984,8 @@ "databricks": "fd3b9424e28fed0134486bc7", "duckdb": "ee8c9d9a91ebec8ca7defc90", "generic": "fd3b9424e28fed0134486bc7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "ee8c9d9a91ebec8ca7defc90", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ee8c9d9a91ebec8ca7defc90", "postgresql": "ee8c9d9a91ebec8ca7defc90", "snowflake": "1d67c9120962e3304f0e1bcc", @@ -9001,8 +9001,8 @@ "databricks": "3a4d8bca5124769db23a43df", "duckdb": "01e3dfc024c37a8d62c7f810", "generic": "3a4d8bca5124769db23a43df", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "01e3dfc024c37a8d62c7f810", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "01e3dfc024c37a8d62c7f810", "postgresql": "01e3dfc024c37a8d62c7f810", "snowflake": "db03b5ccf153c75e43846a6a", @@ -9018,8 +9018,8 @@ "databricks": "791a58207da7e61895ce33f6", "duckdb": "791a58207da7e61895ce33f6", "generic": "791a58207da7e61895ce33f6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "791a58207da7e61895ce33f6", +"motherduck": "791a58207da7e61895ce33f6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "791a58207da7e61895ce33f6", "postgresql": "791a58207da7e61895ce33f6", "snowflake": "791a58207da7e61895ce33f6", @@ -9031,12 +9031,12 @@ { "DuckDB": "461923a0d34defd0c726d6e5", "None": "461923a0d34defd0c726d6e5", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "461923a0d34defd0c726d6e5", "duckdb": "461923a0d34defd0c726d6e5", "generic": "461923a0d34defd0c726d6e5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "461923a0d34defd0c726d6e5", +"motherduck": "461923a0d34defd0c726d6e5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "461923a0d34defd0c726d6e5", "postgresql": "461923a0d34defd0c726d6e5", "snowflake": "461923a0d34defd0c726d6e5", @@ -9048,14 +9048,14 @@ { "DuckDB": "d2c97d221599d038d9875873", "None": "d2c97d221599d038d9875873", -"bigquery": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", "databricks": "d2c97d221599d038d9875873", "duckdb": "d2c97d221599d038d9875873", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "d2c97d221599d038d9875873", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -9064,17 +9064,17 @@ "type", { "DuckDB": "f7fca17b74cc50ae3de8c826", -"None": "f7fca17b74cc50ae3de8c826", -"bigquery": "f7fca17b74cc50ae3de8c826", -"databricks": "f7fca17b74cc50ae3de8c826", +"None": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", +"databricks": "d2c97d221599d038d9875873", "duckdb": "f7fca17b74cc50ae3de8c826", -"generic": "f7fca17b74cc50ae3de8c826", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f7fca17b74cc50ae3de8c826", -"postgres": "f7fca17b74cc50ae3de8c826", -"postgresql": "f7fca17b74cc50ae3de8c826", +"generic": "d2c97d221599d038d9875873", +"motherduck": "f7fca17b74cc50ae3de8c826", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "55155766823b6a3a5e882fc2", -"tsql": "f7fca17b74cc50ae3de8c826" +"tsql": "d2c97d221599d038d9875873" } ], [ @@ -9086,8 +9086,8 @@ "databricks": "ef34121d80f6c399a1a456b1", "duckdb": "ef34121d80f6c399a1a456b1", "generic": "ef34121d80f6c399a1a456b1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ef34121d80f6c399a1a456b1", +"motherduck": "ef34121d80f6c399a1a456b1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ef34121d80f6c399a1a456b1", "postgresql": "ef34121d80f6c399a1a456b1", "snowflake": "ef34121d80f6c399a1a456b1", @@ -9103,8 +9103,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -9116,14 +9116,14 @@ { "DuckDB": "b4284f955ab1914d3f556d82", "None": "b4284f955ab1914d3f556d82", -"bigquery": "b4284f955ab1914d3f556d82", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "b4284f955ab1914d3f556d82", "duckdb": "b4284f955ab1914d3f556d82", "generic": "b4284f955ab1914d3f556d82", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b4284f955ab1914d3f556d82", -"postgres": "b4284f955ab1914d3f556d82", -"postgresql": "b4284f955ab1914d3f556d82", +"motherduck": "b4284f955ab1914d3f556d82", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "063c794e14d2f13bb89a7a4d", +"postgresql": "063c794e14d2f13bb89a7a4d", "snowflake": "b4284f955ab1914d3f556d82", "tsql": "b4284f955ab1914d3f556d82" } @@ -9133,14 +9133,14 @@ { "DuckDB": "c84c0b1d4d7caa6744130456", "None": "c84c0b1d4d7caa6744130456", -"bigquery": "c84c0b1d4d7caa6744130456", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "c84c0b1d4d7caa6744130456", "duckdb": "c84c0b1d4d7caa6744130456", "generic": "c84c0b1d4d7caa6744130456", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c84c0b1d4d7caa6744130456", -"postgres": "c84c0b1d4d7caa6744130456", -"postgresql": "c84c0b1d4d7caa6744130456", +"motherduck": "c84c0b1d4d7caa6744130456", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "725c73e74f311417bb4f95e8", +"postgresql": "725c73e74f311417bb4f95e8", "snowflake": "c84c0b1d4d7caa6744130456", "tsql": "c84c0b1d4d7caa6744130456" } @@ -9150,12 +9150,12 @@ { "DuckDB": "62368fc15cefd5807807b209", "None": "62368fc15cefd5807807b209", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "62368fc15cefd5807807b209", "duckdb": "62368fc15cefd5807807b209", "generic": "62368fc15cefd5807807b209", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "62368fc15cefd5807807b209", +"motherduck": "62368fc15cefd5807807b209", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "62368fc15cefd5807807b209", "postgresql": "62368fc15cefd5807807b209", "snowflake": "62368fc15cefd5807807b209", @@ -9171,8 +9171,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "8441d00030df06ad6a5534d3", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "8441d00030df06ad6a5534d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -9183,17 +9183,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -9205,8 +9205,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -9218,14 +9218,14 @@ { "DuckDB": "73151c1398b30e5c5d18f4ce", "None": "73151c1398b30e5c5d18f4ce", -"bigquery": "73151c1398b30e5c5d18f4ce", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "73151c1398b30e5c5d18f4ce", "duckdb": "73151c1398b30e5c5d18f4ce", "generic": "73151c1398b30e5c5d18f4ce", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73151c1398b30e5c5d18f4ce", -"postgres": "73151c1398b30e5c5d18f4ce", -"postgresql": "73151c1398b30e5c5d18f4ce", +"motherduck": "73151c1398b30e5c5d18f4ce", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f68b7dbd74ec7c3b9f3066ef", +"postgresql": "f68b7dbd74ec7c3b9f3066ef", "snowflake": "73151c1398b30e5c5d18f4ce", "tsql": "73151c1398b30e5c5d18f4ce" } @@ -9239,8 +9239,8 @@ "databricks": "4fb572024031cb7631777be1", "duckdb": "792f7d3389f076f50c713946", "generic": "792f7d3389f076f50c713946", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "792f7d3389f076f50c713946", +"motherduck": "792f7d3389f076f50c713946", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "792f7d3389f076f50c713946", "postgresql": "792f7d3389f076f50c713946", "snowflake": "792f7d3389f076f50c713946", @@ -9256,8 +9256,8 @@ "databricks": "236311169ac0526becd627ac", "duckdb": "236311169ac0526becd627ac", "generic": "236311169ac0526becd627ac", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "236311169ac0526becd627ac", +"motherduck": "236311169ac0526becd627ac", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "236311169ac0526becd627ac", "postgresql": "236311169ac0526becd627ac", "snowflake": "236311169ac0526becd627ac", @@ -9273,10 +9273,10 @@ "databricks": "336fd1b7a1f7d8105c29280c", "duckdb": "0baaca265927140414f32b37", "generic": "336fd1b7a1f7d8105c29280c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "336fd1b7a1f7d8105c29280c", -"postgres": "336fd1b7a1f7d8105c29280c", -"postgresql": "336fd1b7a1f7d8105c29280c", +"motherduck": "0baaca265927140414f32b37", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9ea4932505663b43f527adad", +"postgresql": "9ea4932505663b43f527adad", "snowflake": "336fd1b7a1f7d8105c29280c", "tsql": "336fd1b7a1f7d8105c29280c" } @@ -9290,8 +9290,8 @@ "databricks": "806dd59533345612c07a861b", "duckdb": "806dd59533345612c07a861b", "generic": "806dd59533345612c07a861b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "806dd59533345612c07a861b", +"motherduck": "806dd59533345612c07a861b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "806dd59533345612c07a861b", "postgresql": "806dd59533345612c07a861b", "snowflake": "806dd59533345612c07a861b", @@ -9302,17 +9302,17 @@ "type", { "DuckDB": "647ac9829e390656c0783aba", -"None": "1404468a845477f54df838fc", +"None": "2df0f0517ee87dda5683d2bd", "bigquery": "2df0f0517ee87dda5683d2bd", "databricks": "2df0f0517ee87dda5683d2bd", "duckdb": "647ac9829e390656c0783aba", -"generic": "1404468a845477f54df838fc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2df0f0517ee87dda5683d2bd", -"postgres": "ee5dc4b764837cf002345fb9", -"postgresql": "ee5dc4b764837cf002345fb9", +"generic": "2df0f0517ee87dda5683d2bd", +"motherduck": "647ac9829e390656c0783aba", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2df0f0517ee87dda5683d2bd", +"postgresql": "2df0f0517ee87dda5683d2bd", "snowflake": "8d1f13df6b799b7b301d2e69", -"tsql": "d1dc9a140dbe2eb1874c6ad7" +"tsql": "2df0f0517ee87dda5683d2bd" } ], [ @@ -9324,8 +9324,8 @@ "databricks": "5aa51d84ac5e6c7a9306f348", "duckdb": "5aa51d84ac5e6c7a9306f348", "generic": "5aa51d84ac5e6c7a9306f348", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5aa51d84ac5e6c7a9306f348", +"motherduck": "5aa51d84ac5e6c7a9306f348", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5aa51d84ac5e6c7a9306f348", "postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "5aa51d84ac5e6c7a9306f348", @@ -9336,15 +9336,15 @@ "type", { "DuckDB": "6247229b9f890f25e7b3f0c5", -"None": "eb8ea3778b2debde09f2afb1", -"bigquery": "135a912ea74f76a35d9d0632", -"databricks": "eb8ea3778b2debde09f2afb1", +"None": "3fd7037beaaa396764e49e8b", +"bigquery": "3fd7037beaaa396764e49e8b", +"databricks": "3fd7037beaaa396764e49e8b", "duckdb": "6247229b9f890f25e7b3f0c5", -"generic": "eb8ea3778b2debde09f2afb1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "6247229b9f890f25e7b3f0c5", -"postgresql": "6247229b9f890f25e7b3f0c5", +"generic": "3fd7037beaaa396764e49e8b", +"motherduck": "6247229b9f890f25e7b3f0c5", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3fd7037beaaa396764e49e8b", +"postgresql": "3fd7037beaaa396764e49e8b", "snowflake": "8f60ea843371b982d069e65b", "tsql": "3fd7037beaaa396764e49e8b" } @@ -9358,8 +9358,8 @@ "databricks": "a57535ee64678e69d1acd48a", "duckdb": "077cc38442b3b9eae7bb07d0", "generic": "a57535ee64678e69d1acd48a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "077cc38442b3b9eae7bb07d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "077cc38442b3b9eae7bb07d0", "postgresql": "077cc38442b3b9eae7bb07d0", "snowflake": "befa13a14d1144835e866a4d", @@ -9375,8 +9375,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -9392,8 +9392,8 @@ "databricks": "ff8f9d6dbbdd5b3cf2e7c198", "duckdb": "ff8f9d6dbbdd5b3cf2e7c198", "generic": "ff8f9d6dbbdd5b3cf2e7c198", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ff8f9d6dbbdd5b3cf2e7c198", +"motherduck": "ff8f9d6dbbdd5b3cf2e7c198", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ff8f9d6dbbdd5b3cf2e7c198", "postgresql": "ff8f9d6dbbdd5b3cf2e7c198", "snowflake": "ff8f9d6dbbdd5b3cf2e7c198", @@ -9405,14 +9405,14 @@ { "DuckDB": "4928771fd9e503a30457d160", "None": "4928771fd9e503a30457d160", -"bigquery": "4928771fd9e503a30457d160", +"bigquery": "67d251c042daee0bb2bf7351", "databricks": "4928771fd9e503a30457d160", "duckdb": "4928771fd9e503a30457d160", "generic": "4928771fd9e503a30457d160", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4928771fd9e503a30457d160", -"postgres": "4928771fd9e503a30457d160", -"postgresql": "4928771fd9e503a30457d160", +"motherduck": "4928771fd9e503a30457d160", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "50ddfb168c08b09892261e82", +"postgresql": "50ddfb168c08b09892261e82", "snowflake": "4928771fd9e503a30457d160", "tsql": "4928771fd9e503a30457d160" } @@ -9426,10 +9426,10 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "b8321619b794db091c9e96a1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b8321619b794db091c9e96a1", -"postgres": "b8321619b794db091c9e96a1", -"postgresql": "b8321619b794db091c9e96a1", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "bce26544873d6ec9191c9a86", +"postgresql": "bce26544873d6ec9191c9a86", "snowflake": "b8321619b794db091c9e96a1", "tsql": "b8321619b794db091c9e96a1" } @@ -9440,11 +9440,11 @@ "DuckDB": "a0e5b4ce93e9317c3cea1cbf", "None": "a0e5b4ce93e9317c3cea1cbf", "bigquery": "a0e5b4ce93e9317c3cea1cbf", -"databricks": "c9d23fd01aedfa8b27cf08a6", +"databricks": "a0e5b4ce93e9317c3cea1cbf", "duckdb": "a0e5b4ce93e9317c3cea1cbf", "generic": "a0e5b4ce93e9317c3cea1cbf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c8a1fc1b91adcea5a885afe3", +"motherduck": "a0e5b4ce93e9317c3cea1cbf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a0e5b4ce93e9317c3cea1cbf", "postgresql": "a0e5b4ce93e9317c3cea1cbf", "snowflake": "a0e5b4ce93e9317c3cea1cbf", @@ -9460,8 +9460,8 @@ "databricks": "78de20f17ea5d66780a9f32e", "duckdb": "78de20f17ea5d66780a9f32e", "generic": "78de20f17ea5d66780a9f32e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "78de20f17ea5d66780a9f32e", +"motherduck": "78de20f17ea5d66780a9f32e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "78de20f17ea5d66780a9f32e", "postgresql": "78de20f17ea5d66780a9f32e", "snowflake": "78de20f17ea5d66780a9f32e", @@ -9477,8 +9477,8 @@ "databricks": "40f264d27364684659f815eb", "duckdb": "8bb8eb3ad4ee794b787a664d", "generic": "8bb8eb3ad4ee794b787a664d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8bb8eb3ad4ee794b787a664d", +"motherduck": "8bb8eb3ad4ee794b787a664d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8bb8eb3ad4ee794b787a664d", "postgresql": "8bb8eb3ad4ee794b787a664d", "snowflake": "469cddcff389dac525f4efdf", @@ -9490,14 +9490,14 @@ { "DuckDB": "e46d4be44ab9e500e9190d26", "None": "e46d4be44ab9e500e9190d26", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -9511,10 +9511,10 @@ "databricks": "3673b4fbbd8a7fed7120ec2b", "duckdb": "3673b4fbbd8a7fed7120ec2b", "generic": "3673b4fbbd8a7fed7120ec2b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3673b4fbbd8a7fed7120ec2b", -"postgres": "3673b4fbbd8a7fed7120ec2b", -"postgresql": "3673b4fbbd8a7fed7120ec2b", +"motherduck": "3673b4fbbd8a7fed7120ec2b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9aff7fcc7d550e1a8d105471", +"postgresql": "9aff7fcc7d550e1a8d105471", "snowflake": "3673b4fbbd8a7fed7120ec2b", "tsql": "3673b4fbbd8a7fed7120ec2b" } @@ -9523,17 +9523,17 @@ "type", { "DuckDB": "a3b6b25265be330ec52a3322", -"None": "a3b6b25265be330ec52a3322", -"bigquery": "204206d1d1eecf007966cc5b", -"databricks": "e3bc1b8bad22d8104417b00f", +"None": "62368fc15cefd5807807b209", +"bigquery": "c50a316d091c821866e4bfba", +"databricks": "62368fc15cefd5807807b209", "duckdb": "a3b6b25265be330ec52a3322", -"generic": "a3b6b25265be330ec52a3322", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "919b7ec6a7b49d8527b784cd", -"postgres": "a3b6b25265be330ec52a3322", -"postgresql": "a3b6b25265be330ec52a3322", +"generic": "62368fc15cefd5807807b209", +"motherduck": "a3b6b25265be330ec52a3322", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "62368fc15cefd5807807b209", +"postgresql": "62368fc15cefd5807807b209", "snowflake": "919b7ec6a7b49d8527b784cd", -"tsql": "a3b6b25265be330ec52a3322" +"tsql": "62368fc15cefd5807807b209" } ], [ @@ -9541,14 +9541,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -9562,8 +9562,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -9579,8 +9579,8 @@ "databricks": "0b8ad171901cc2b7725617da", "duckdb": "0b8ad171901cc2b7725617da", "generic": "0b8ad171901cc2b7725617da", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0b8ad171901cc2b7725617da", +"motherduck": "0b8ad171901cc2b7725617da", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0b8ad171901cc2b7725617da", "postgresql": "0b8ad171901cc2b7725617da", "snowflake": "0b8ad171901cc2b7725617da", @@ -9596,8 +9596,8 @@ "databricks": "97dfbcc6528a197a87add69e", "duckdb": "208eafc9a5aab337867bb773", "generic": "97dfbcc6528a197a87add69e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "208eafc9a5aab337867bb773", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ca3d3fa7d8eb1608bd8752de", "postgresql": "ca3d3fa7d8eb1608bd8752de", "snowflake": "46250b305f6ac5a95e4d3083", @@ -9613,8 +9613,8 @@ "databricks": "c4d601bdc1b1f357b3e9bbdf", "duckdb": "c4d601bdc1b1f357b3e9bbdf", "generic": "c4d601bdc1b1f357b3e9bbdf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c4d601bdc1b1f357b3e9bbdf", +"motherduck": "c4d601bdc1b1f357b3e9bbdf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c4d601bdc1b1f357b3e9bbdf", "postgresql": "c4d601bdc1b1f357b3e9bbdf", "snowflake": "c4d601bdc1b1f357b3e9bbdf", @@ -9630,10 +9630,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -9647,8 +9647,8 @@ "databricks": "e7c121d9cbaf6e6b91cfdf74", "duckdb": "e7c121d9cbaf6e6b91cfdf74", "generic": "e7c121d9cbaf6e6b91cfdf74", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e7c121d9cbaf6e6b91cfdf74", +"motherduck": "e7c121d9cbaf6e6b91cfdf74", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e7c121d9cbaf6e6b91cfdf74", "postgresql": "e7c121d9cbaf6e6b91cfdf74", "snowflake": "e7c121d9cbaf6e6b91cfdf74", @@ -9664,8 +9664,8 @@ "databricks": "962ea05bab624c1f8c259a65", "duckdb": "962ea05bab624c1f8c259a65", "generic": "962ea05bab624c1f8c259a65", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "962ea05bab624c1f8c259a65", +"motherduck": "962ea05bab624c1f8c259a65", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "962ea05bab624c1f8c259a65", "postgresql": "962ea05bab624c1f8c259a65", "snowflake": "962ea05bab624c1f8c259a65", @@ -9677,12 +9677,12 @@ { "DuckDB": "3e888d249494102b9ba328b2", "None": "3e888d249494102b9ba328b2", -"bigquery": "3e888d249494102b9ba328b2", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "3e888d249494102b9ba328b2", "duckdb": "3e888d249494102b9ba328b2", "generic": "3e888d249494102b9ba328b2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3e888d249494102b9ba328b2", +"motherduck": "3e888d249494102b9ba328b2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3e888d249494102b9ba328b2", "postgresql": "3e888d249494102b9ba328b2", "snowflake": "3e888d249494102b9ba328b2", @@ -9698,8 +9698,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -9715,8 +9715,8 @@ "databricks": "652ff8b21f638eac8fdc46c5", "duckdb": "652ff8b21f638eac8fdc46c5", "generic": "652ff8b21f638eac8fdc46c5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "652ff8b21f638eac8fdc46c5", +"motherduck": "652ff8b21f638eac8fdc46c5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "652ff8b21f638eac8fdc46c5", "postgresql": "652ff8b21f638eac8fdc46c5", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -9728,12 +9728,12 @@ { "DuckDB": "0989b67047ee9c0a1d9f2cf4", "None": "0989b67047ee9c0a1d9f2cf4", -"bigquery": "0989b67047ee9c0a1d9f2cf4", +"bigquery": "e1c1429838b93039324a47f3", "databricks": "0989b67047ee9c0a1d9f2cf4", "duckdb": "0989b67047ee9c0a1d9f2cf4", "generic": "0989b67047ee9c0a1d9f2cf4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0989b67047ee9c0a1d9f2cf4", +"motherduck": "0989b67047ee9c0a1d9f2cf4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0989b67047ee9c0a1d9f2cf4", "postgresql": "0989b67047ee9c0a1d9f2cf4", "snowflake": "0989b67047ee9c0a1d9f2cf4", @@ -9749,8 +9749,8 @@ "databricks": "1275b5b0c52f69cf592c004b", "duckdb": "1275b5b0c52f69cf592c004b", "generic": "1275b5b0c52f69cf592c004b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1275b5b0c52f69cf592c004b", +"motherduck": "1275b5b0c52f69cf592c004b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1275b5b0c52f69cf592c004b", "postgresql": "1275b5b0c52f69cf592c004b", "snowflake": "1275b5b0c52f69cf592c004b", @@ -9762,14 +9762,14 @@ { "DuckDB": "3e611643f0beab4953c4e09b", "None": "3e611643f0beab4953c4e09b", -"bigquery": "2a0918be53051fe629d9ff8f", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "3e611643f0beab4953c4e09b", "duckdb": "3e611643f0beab4953c4e09b", "generic": "3e611643f0beab4953c4e09b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3e611643f0beab4953c4e09b", -"postgres": "3e611643f0beab4953c4e09b", -"postgresql": "3e611643f0beab4953c4e09b", +"motherduck": "3e611643f0beab4953c4e09b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "cae477ce59c72869f37a9a40", +"postgresql": "cae477ce59c72869f37a9a40", "snowflake": "3e611643f0beab4953c4e09b", "tsql": "3e611643f0beab4953c4e09b" } @@ -9779,14 +9779,14 @@ { "DuckDB": "e46d4be44ab9e500e9190d26", "None": "e46d4be44ab9e500e9190d26", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -9800,8 +9800,8 @@ "databricks": "70fb4728c3adcf6dbe4975d5", "duckdb": "70fb4728c3adcf6dbe4975d5", "generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", @@ -9817,10 +9817,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -9830,14 +9830,14 @@ { "DuckDB": "b6b82efd03def9465e4f97b2", "None": "b6b82efd03def9465e4f97b2", -"bigquery": "b6b82efd03def9465e4f97b2", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "b6b82efd03def9465e4f97b2", "duckdb": "b6b82efd03def9465e4f97b2", "generic": "b6b82efd03def9465e4f97b2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b6b82efd03def9465e4f97b2", -"postgres": "b6b82efd03def9465e4f97b2", -"postgresql": "b6b82efd03def9465e4f97b2", +"motherduck": "b6b82efd03def9465e4f97b2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a3923c3d2c49043629c52bf6", +"postgresql": "a3923c3d2c49043629c52bf6", "snowflake": "b6b82efd03def9465e4f97b2", "tsql": "b6b82efd03def9465e4f97b2" } @@ -9851,10 +9851,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -9868,10 +9868,10 @@ "databricks": "80c23e10e486925cf3b33f9d", "duckdb": "80c23e10e486925cf3b33f9d", "generic": "80c23e10e486925cf3b33f9d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "80c23e10e486925cf3b33f9d", -"postgres": "80c23e10e486925cf3b33f9d", -"postgresql": "80c23e10e486925cf3b33f9d", +"motherduck": "80c23e10e486925cf3b33f9d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "30466b1eff038acb4463e46d", +"postgresql": "30466b1eff038acb4463e46d", "snowflake": "80c23e10e486925cf3b33f9d", "tsql": "80c23e10e486925cf3b33f9d" } @@ -9885,8 +9885,8 @@ "databricks": "60a23b7dcae6c79f4de83068", "duckdb": "60a23b7dcae6c79f4de83068", "generic": "60a23b7dcae6c79f4de83068", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "60a23b7dcae6c79f4de83068", +"motherduck": "60a23b7dcae6c79f4de83068", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "60a23b7dcae6c79f4de83068", "postgresql": "60a23b7dcae6c79f4de83068", "snowflake": "60a23b7dcae6c79f4de83068", @@ -9902,8 +9902,8 @@ "databricks": "f4c43a87a78970bca1f88b09", "duckdb": "f4c43a87a78970bca1f88b09", "generic": "f4c43a87a78970bca1f88b09", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f4c43a87a78970bca1f88b09", +"motherduck": "f4c43a87a78970bca1f88b09", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f4c43a87a78970bca1f88b09", "postgresql": "f4c43a87a78970bca1f88b09", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -9919,8 +9919,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -9932,14 +9932,14 @@ { "DuckDB": "c4346d0257336219f1d26890", "None": "c4346d0257336219f1d26890", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "c4346d0257336219f1d26890", "duckdb": "c4346d0257336219f1d26890", "generic": "c4346d0257336219f1d26890", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c4346d0257336219f1d26890", -"postgres": "c4346d0257336219f1d26890", -"postgresql": "c4346d0257336219f1d26890", +"motherduck": "c4346d0257336219f1d26890", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "19bdd92ea0cc5fb028657510", +"postgresql": "19bdd92ea0cc5fb028657510", "snowflake": "4e24a80b20b9dee0cbbfac17", "tsql": "c4346d0257336219f1d26890" } @@ -9953,8 +9953,8 @@ "databricks": "cabeb00c4bc6c9e3d88a79ed", "duckdb": "bcc4b2c4a8f93d406cf00bc8", "generic": "cabeb00c4bc6c9e3d88a79ed", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "bcc4b2c4a8f93d406cf00bc8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "bcc4b2c4a8f93d406cf00bc8", "postgresql": "bcc4b2c4a8f93d406cf00bc8", "snowflake": "c4046288c6fec9a1344b0faa", @@ -9970,8 +9970,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -9983,14 +9983,14 @@ { "DuckDB": "d2c97d221599d038d9875873", "None": "d2c97d221599d038d9875873", -"bigquery": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", "databricks": "d2c97d221599d038d9875873", "duckdb": "d2c97d221599d038d9875873", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "d2c97d221599d038d9875873", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -10004,10 +10004,10 @@ "databricks": "d227b99a82e505d599c2ed8a", "duckdb": "35a9c5c1419bff507cf65ae2", "generic": "d227b99a82e505d599c2ed8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d227b99a82e505d599c2ed8a", -"postgres": "d227b99a82e505d599c2ed8a", -"postgresql": "d227b99a82e505d599c2ed8a", +"motherduck": "35a9c5c1419bff507cf65ae2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "35a9c5c1419bff507cf65ae2", +"postgresql": "35a9c5c1419bff507cf65ae2", "snowflake": "d227b99a82e505d599c2ed8a", "tsql": "d227b99a82e505d599c2ed8a" } @@ -10021,8 +10021,8 @@ "databricks": "fa07c8ec6ebf3228010ebd9a", "duckdb": "fa07c8ec6ebf3228010ebd9a", "generic": "fa07c8ec6ebf3228010ebd9a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fa07c8ec6ebf3228010ebd9a", +"motherduck": "fa07c8ec6ebf3228010ebd9a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fa07c8ec6ebf3228010ebd9a", "postgresql": "fa07c8ec6ebf3228010ebd9a", "snowflake": "fa07c8ec6ebf3228010ebd9a", @@ -10038,8 +10038,8 @@ "databricks": "ab5ad6180652b3b00d1f5b01", "duckdb": "ab5ad6180652b3b00d1f5b01", "generic": "ab5ad6180652b3b00d1f5b01", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ab5ad6180652b3b00d1f5b01", +"motherduck": "ab5ad6180652b3b00d1f5b01", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ab5ad6180652b3b00d1f5b01", "postgresql": "ab5ad6180652b3b00d1f5b01", "snowflake": "226beccc1d430773f4e67b70", @@ -10050,17 +10050,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -10072,10 +10072,10 @@ "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "35e216b6921bf843994f2eea", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "35e216b6921bf843994f2eea", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -10089,8 +10089,8 @@ "databricks": "c2700ca3573352821e09af03", "duckdb": "c2700ca3573352821e09af03", "generic": "c2700ca3573352821e09af03", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c2700ca3573352821e09af03", +"motherduck": "c2700ca3573352821e09af03", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c2700ca3573352821e09af03", "postgresql": "c2700ca3573352821e09af03", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -10106,8 +10106,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -10123,8 +10123,8 @@ "databricks": "4b27937f44f966ff9f3a7c76", "duckdb": "4b27937f44f966ff9f3a7c76", "generic": "4b27937f44f966ff9f3a7c76", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4b27937f44f966ff9f3a7c76", +"motherduck": "4b27937f44f966ff9f3a7c76", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4b27937f44f966ff9f3a7c76", "postgresql": "4b27937f44f966ff9f3a7c76", "snowflake": "4b27937f44f966ff9f3a7c76", @@ -10140,8 +10140,8 @@ "databricks": "d63e1b6839b94c8b42376477", "duckdb": "d63e1b6839b94c8b42376477", "generic": "d63e1b6839b94c8b42376477", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d63e1b6839b94c8b42376477", +"motherduck": "d63e1b6839b94c8b42376477", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d63e1b6839b94c8b42376477", "postgresql": "d63e1b6839b94c8b42376477", "snowflake": "d63e1b6839b94c8b42376477", @@ -10157,8 +10157,8 @@ "databricks": "c752fd9fe2ad3b86b8b899da", "duckdb": "c752fd9fe2ad3b86b8b899da", "generic": "c752fd9fe2ad3b86b8b899da", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c752fd9fe2ad3b86b8b899da", +"motherduck": "c752fd9fe2ad3b86b8b899da", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e998cd8f0f74af0526b75ff0", "postgresql": "e998cd8f0f74af0526b75ff0", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -10174,8 +10174,8 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "1e75e5227bea0ae294ac7af1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19bdd92ea0cc5fb028657510", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "19bdd92ea0cc5fb028657510", "postgresql": "19bdd92ea0cc5fb028657510", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -10191,8 +10191,8 @@ "databricks": "57922064a7dc546cbb50e42b", "duckdb": "57922064a7dc546cbb50e42b", "generic": "57922064a7dc546cbb50e42b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "57922064a7dc546cbb50e42b", +"motherduck": "57922064a7dc546cbb50e42b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "57922064a7dc546cbb50e42b", "postgresql": "57922064a7dc546cbb50e42b", "snowflake": "57922064a7dc546cbb50e42b", @@ -10208,8 +10208,8 @@ "databricks": "d4a375fcf7c3190951992469", "duckdb": "d4a375fcf7c3190951992469", "generic": "d4a375fcf7c3190951992469", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d4a375fcf7c3190951992469", +"motherduck": "d4a375fcf7c3190951992469", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d4a375fcf7c3190951992469", "postgresql": "d4a375fcf7c3190951992469", "snowflake": "6306b9e88f7b13dbb6a32c00", @@ -10219,16 +10219,16 @@ [ "type", { -"DuckDB": "8698d724534891869075175e", -"None": "0017a88bb60ec3403c786ed8", +"DuckDB": "aa7afbd57560be67e5221a3b", +"None": "47e0816fecdd9e015d7aeb79", "bigquery": "47e0816fecdd9e015d7aeb79", -"databricks": "0017a88bb60ec3403c786ed8", -"duckdb": "8698d724534891869075175e", -"generic": "0017a88bb60ec3403c786ed8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "8698d724534891869075175e", -"postgresql": "8698d724534891869075175e", +"databricks": "47e0816fecdd9e015d7aeb79", +"duckdb": "aa7afbd57560be67e5221a3b", +"generic": "47e0816fecdd9e015d7aeb79", +"motherduck": "aa7afbd57560be67e5221a3b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "aa7afbd57560be67e5221a3b", +"postgresql": "aa7afbd57560be67e5221a3b", "snowflake": "e6f36041b1d9fb8fe3a18cbb", "tsql": "364031fff119e6530478e415" } @@ -10242,8 +10242,8 @@ "databricks": "14c32cfb5e5135338d015f42", "duckdb": "14c32cfb5e5135338d015f42", "generic": "14c32cfb5e5135338d015f42", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "14c32cfb5e5135338d015f42", +"motherduck": "14c32cfb5e5135338d015f42", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "14c32cfb5e5135338d015f42", "postgresql": "14c32cfb5e5135338d015f42", "snowflake": "14c32cfb5e5135338d015f42", @@ -10259,8 +10259,8 @@ "databricks": "73d31c6e78cdc3b595b9c4e9", "duckdb": "73d31c6e78cdc3b595b9c4e9", "generic": "73d31c6e78cdc3b595b9c4e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73d31c6e78cdc3b595b9c4e9", +"motherduck": "73d31c6e78cdc3b595b9c4e9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "73d31c6e78cdc3b595b9c4e9", "postgresql": "73d31c6e78cdc3b595b9c4e9", "snowflake": "73d31c6e78cdc3b595b9c4e9", @@ -10276,10 +10276,10 @@ "databricks": "6f763a99e9c69109526b40c0", "duckdb": "6f763a99e9c69109526b40c0", "generic": "6f763a99e9c69109526b40c0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6f763a99e9c69109526b40c0", -"postgres": "6f763a99e9c69109526b40c0", -"postgresql": "6f763a99e9c69109526b40c0", +"motherduck": "6f763a99e9c69109526b40c0", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5226d7e2a62c7650a87d6e84", +"postgresql": "5226d7e2a62c7650a87d6e84", "snowflake": "2705f19942a4194a72576911", "tsql": "6f763a99e9c69109526b40c0" } @@ -10293,8 +10293,8 @@ "databricks": "78b2cf275c640af54feeca31", "duckdb": "78b2cf275c640af54feeca31", "generic": "78b2cf275c640af54feeca31", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "78b2cf275c640af54feeca31", +"motherduck": "78b2cf275c640af54feeca31", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "78b2cf275c640af54feeca31", "postgresql": "78b2cf275c640af54feeca31", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -10310,10 +10310,10 @@ "databricks": "f78e07518606fbc42e0f28fe", "duckdb": "f78e07518606fbc42e0f28fe", "generic": "f78e07518606fbc42e0f28fe", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f78e07518606fbc42e0f28fe", -"postgres": "f78e07518606fbc42e0f28fe", -"postgresql": "f78e07518606fbc42e0f28fe", +"motherduck": "f78e07518606fbc42e0f28fe", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "726bc47de786f118c37530f7", +"postgresql": "726bc47de786f118c37530f7", "snowflake": "f78e07518606fbc42e0f28fe", "tsql": "f78e07518606fbc42e0f28fe" } @@ -10327,8 +10327,8 @@ "databricks": "11f5a5e0f332f3a87c8ff396", "duckdb": "11f5a5e0f332f3a87c8ff396", "generic": "11f5a5e0f332f3a87c8ff396", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "11f5a5e0f332f3a87c8ff396", +"motherduck": "11f5a5e0f332f3a87c8ff396", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "11f5a5e0f332f3a87c8ff396", "postgresql": "11f5a5e0f332f3a87c8ff396", "snowflake": "11f5a5e0f332f3a87c8ff396", @@ -10344,8 +10344,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -10355,18 +10355,18 @@ [ "type", { -"DuckDB": "f20ec02865769c13aa2d2b67", -"None": "f20ec02865769c13aa2d2b67", -"bigquery": "8575088c2f44d4349e1307a4", -"databricks": "e40ec5056d50c25089ee3934", -"duckdb": "f20ec02865769c13aa2d2b67", -"generic": "f20ec02865769c13aa2d2b67", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f20ec02865769c13aa2d2b67", -"postgres": "f20ec02865769c13aa2d2b67", -"postgresql": "f20ec02865769c13aa2d2b67", -"snowflake": "e5502f3bf9aad4d98960c7b4", -"tsql": "f20ec02865769c13aa2d2b67" +"DuckDB": "143fb490be175b5b233c87a4", +"None": "143fb490be175b5b233c87a4", +"bigquery": "5391753213125132f9ba8258", +"databricks": "e95f9763c510e80ddb1422a0", +"duckdb": "143fb490be175b5b233c87a4", +"generic": "143fb490be175b5b233c87a4", +"motherduck": "143fb490be175b5b233c87a4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "143fb490be175b5b233c87a4", +"postgresql": "143fb490be175b5b233c87a4", +"snowflake": "e6d0f723aa7559449fb75d84", +"tsql": "143fb490be175b5b233c87a4" } ], [ @@ -10378,8 +10378,8 @@ "databricks": "d22967425ad0e5a048596ac6", "duckdb": "d22967425ad0e5a048596ac6", "generic": "d22967425ad0e5a048596ac6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d22967425ad0e5a048596ac6", +"motherduck": "d22967425ad0e5a048596ac6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d22967425ad0e5a048596ac6", "postgresql": "d22967425ad0e5a048596ac6", "snowflake": "d22967425ad0e5a048596ac6", @@ -10395,8 +10395,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -10412,8 +10412,8 @@ "databricks": "eded69a48ff8476dbf73ff05", "duckdb": "eded69a48ff8476dbf73ff05", "generic": "eded69a48ff8476dbf73ff05", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "eded69a48ff8476dbf73ff05", +"motherduck": "eded69a48ff8476dbf73ff05", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "eded69a48ff8476dbf73ff05", "postgresql": "eded69a48ff8476dbf73ff05", "snowflake": "eded69a48ff8476dbf73ff05", @@ -10429,10 +10429,10 @@ "databricks": "d7bedd3c7663f140f4d10bd4", "duckdb": "d7bedd3c7663f140f4d10bd4", "generic": "d7bedd3c7663f140f4d10bd4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d7bedd3c7663f140f4d10bd4", -"postgres": "d7bedd3c7663f140f4d10bd4", -"postgresql": "d7bedd3c7663f140f4d10bd4", +"motherduck": "d7bedd3c7663f140f4d10bd4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "d7e01d31db59d1d0507cd75c", +"postgresql": "d7e01d31db59d1d0507cd75c", "snowflake": "d7bedd3c7663f140f4d10bd4", "tsql": "d7bedd3c7663f140f4d10bd4" } @@ -10442,14 +10442,14 @@ { "DuckDB": "d2c97d221599d038d9875873", "None": "d2c97d221599d038d9875873", -"bigquery": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", "databricks": "d2c97d221599d038d9875873", "duckdb": "d2c97d221599d038d9875873", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "d2c97d221599d038d9875873", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -10463,8 +10463,8 @@ "databricks": "c82815abe30b3d099903f838", "duckdb": "c82815abe30b3d099903f838", "generic": "c82815abe30b3d099903f838", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c82815abe30b3d099903f838", +"motherduck": "c82815abe30b3d099903f838", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c82815abe30b3d099903f838", "postgresql": "c82815abe30b3d099903f838", "snowflake": "c82815abe30b3d099903f838", @@ -10480,8 +10480,8 @@ "databricks": "3739567e772c71d3b587ca23", "duckdb": "3739567e772c71d3b587ca23", "generic": "3739567e772c71d3b587ca23", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3739567e772c71d3b587ca23", +"motherduck": "3739567e772c71d3b587ca23", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3739567e772c71d3b587ca23", "postgresql": "3739567e772c71d3b587ca23", "snowflake": "3739567e772c71d3b587ca23", @@ -10497,8 +10497,8 @@ "databricks": "83fdbd1f0a6ee4e72faa4d94", "duckdb": "83fdbd1f0a6ee4e72faa4d94", "generic": "83fdbd1f0a6ee4e72faa4d94", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "83fdbd1f0a6ee4e72faa4d94", +"motherduck": "83fdbd1f0a6ee4e72faa4d94", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "83fdbd1f0a6ee4e72faa4d94", "postgresql": "83fdbd1f0a6ee4e72faa4d94", "snowflake": "83fdbd1f0a6ee4e72faa4d94", @@ -10510,12 +10510,12 @@ { "DuckDB": "af57dd2575fa5a01917ec9cf", "None": "af57dd2575fa5a01917ec9cf", -"bigquery": "af57dd2575fa5a01917ec9cf", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "af57dd2575fa5a01917ec9cf", "duckdb": "af57dd2575fa5a01917ec9cf", "generic": "af57dd2575fa5a01917ec9cf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "af57dd2575fa5a01917ec9cf", +"motherduck": "af57dd2575fa5a01917ec9cf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "af57dd2575fa5a01917ec9cf", "postgresql": "af57dd2575fa5a01917ec9cf", "snowflake": "af57dd2575fa5a01917ec9cf", @@ -10531,8 +10531,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -10548,8 +10548,8 @@ "databricks": "d3bcf10e00645b12a802c7d0", "duckdb": "c0eec31620dfc2ac0028173d", "generic": "d3bcf10e00645b12a802c7d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "c0eec31620dfc2ac0028173d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c0eec31620dfc2ac0028173d", "postgresql": "c0eec31620dfc2ac0028173d", "snowflake": "d379c0ee4dad89e570b7329e", @@ -10565,8 +10565,8 @@ "databricks": "39257e40f37cf05c780a4e22", "duckdb": "39257e40f37cf05c780a4e22", "generic": "39257e40f37cf05c780a4e22", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "39257e40f37cf05c780a4e22", +"motherduck": "39257e40f37cf05c780a4e22", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "39257e40f37cf05c780a4e22", "postgresql": "39257e40f37cf05c780a4e22", "snowflake": "39257e40f37cf05c780a4e22", @@ -10578,14 +10578,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -10599,8 +10599,8 @@ "databricks": "251aba3fef503ce64556c701", "duckdb": "251aba3fef503ce64556c701", "generic": "251aba3fef503ce64556c701", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "251aba3fef503ce64556c701", +"motherduck": "251aba3fef503ce64556c701", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "251aba3fef503ce64556c701", "postgresql": "251aba3fef503ce64556c701", "snowflake": "c50a316d091c821866e4bfba", @@ -10612,12 +10612,12 @@ { "DuckDB": "aae2b1fe6f2d9807ecde412b", "None": "aae2b1fe6f2d9807ecde412b", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "aae2b1fe6f2d9807ecde412b", "duckdb": "aae2b1fe6f2d9807ecde412b", "generic": "aae2b1fe6f2d9807ecde412b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aae2b1fe6f2d9807ecde412b", +"motherduck": "aae2b1fe6f2d9807ecde412b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "aae2b1fe6f2d9807ecde412b", "postgresql": "aae2b1fe6f2d9807ecde412b", "snowflake": "aae2b1fe6f2d9807ecde412b", @@ -10633,8 +10633,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -10650,8 +10650,8 @@ "databricks": "251aba3fef503ce64556c701", "duckdb": "251aba3fef503ce64556c701", "generic": "251aba3fef503ce64556c701", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "251aba3fef503ce64556c701", +"motherduck": "251aba3fef503ce64556c701", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "251aba3fef503ce64556c701", "postgresql": "251aba3fef503ce64556c701", "snowflake": "c50a316d091c821866e4bfba", @@ -10667,8 +10667,8 @@ "databricks": "1bdf5908ca249b2331a0427c", "duckdb": "1bdf5908ca249b2331a0427c", "generic": "1bdf5908ca249b2331a0427c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1bdf5908ca249b2331a0427c", +"motherduck": "1bdf5908ca249b2331a0427c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1bdf5908ca249b2331a0427c", "postgresql": "1bdf5908ca249b2331a0427c", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -10684,8 +10684,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -10701,8 +10701,8 @@ "databricks": "53ec6db7b2c81e2ceee285a3", "duckdb": "53ec6db7b2c81e2ceee285a3", "generic": "53ec6db7b2c81e2ceee285a3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "53ec6db7b2c81e2ceee285a3", +"motherduck": "53ec6db7b2c81e2ceee285a3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "53ec6db7b2c81e2ceee285a3", "postgresql": "53ec6db7b2c81e2ceee285a3", "snowflake": "53ec6db7b2c81e2ceee285a3", @@ -10713,17 +10713,17 @@ "type", { "DuckDB": "5abf4ec799a2ec32fb10da7e", -"None": "5abf4ec799a2ec32fb10da7e", -"bigquery": "5abf4ec799a2ec32fb10da7e", -"databricks": "5abf4ec799a2ec32fb10da7e", +"None": "4b356542044f1267fcfc487a", +"bigquery": "a5656d70e208254d1d3e9b4f", +"databricks": "4b356542044f1267fcfc487a", "duckdb": "5abf4ec799a2ec32fb10da7e", -"generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", -"postgres": "5abf4ec799a2ec32fb10da7e", -"postgresql": "5abf4ec799a2ec32fb10da7e", +"generic": "4b356542044f1267fcfc487a", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a5656d70e208254d1d3e9b4f", +"postgresql": "a5656d70e208254d1d3e9b4f", "snowflake": "a5656d70e208254d1d3e9b4f", -"tsql": "5abf4ec799a2ec32fb10da7e" +"tsql": "4b356542044f1267fcfc487a" } ], [ @@ -10731,12 +10731,12 @@ { "DuckDB": "461923a0d34defd0c726d6e5", "None": "461923a0d34defd0c726d6e5", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "461923a0d34defd0c726d6e5", "duckdb": "461923a0d34defd0c726d6e5", "generic": "461923a0d34defd0c726d6e5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "461923a0d34defd0c726d6e5", +"motherduck": "461923a0d34defd0c726d6e5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "461923a0d34defd0c726d6e5", "postgresql": "461923a0d34defd0c726d6e5", "snowflake": "461923a0d34defd0c726d6e5", @@ -10752,8 +10752,8 @@ "databricks": "2427f5522575cdc3d6a74e4c", "duckdb": "2427f5522575cdc3d6a74e4c", "generic": "2427f5522575cdc3d6a74e4c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2427f5522575cdc3d6a74e4c", +"motherduck": "2427f5522575cdc3d6a74e4c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2427f5522575cdc3d6a74e4c", "postgresql": "2427f5522575cdc3d6a74e4c", "snowflake": "2427f5522575cdc3d6a74e4c", @@ -10765,14 +10765,14 @@ { "DuckDB": "158229f1c3f1085b80d3190e", "None": "158229f1c3f1085b80d3190e", -"bigquery": "158229f1c3f1085b80d3190e", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "158229f1c3f1085b80d3190e", "duckdb": "158229f1c3f1085b80d3190e", "generic": "158229f1c3f1085b80d3190e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "158229f1c3f1085b80d3190e", -"postgres": "158229f1c3f1085b80d3190e", -"postgresql": "158229f1c3f1085b80d3190e", +"motherduck": "158229f1c3f1085b80d3190e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "7a1a9517a8cf96477b67c17e", +"postgresql": "7a1a9517a8cf96477b67c17e", "snowflake": "158229f1c3f1085b80d3190e", "tsql": "158229f1c3f1085b80d3190e" } @@ -10786,11 +10786,11 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "e3bc1b8bad22d8104417b00f", "generic": "e3bc1b8bad22d8104417b00f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e3bc1b8bad22d8104417b00f", -"postgres": "111af35848fe500ec2ae54b2", -"postgresql": "111af35848fe500ec2ae54b2", -"snowflake": "e3bc1b8bad22d8104417b00f", +"motherduck": "e3bc1b8bad22d8104417b00f", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "b7d6fc051a3c1ea6deb29ff4", +"postgresql": "b7d6fc051a3c1ea6deb29ff4", +"snowflake": "e3bc1b8bad22d8104417b00f", "tsql": "e3bc1b8bad22d8104417b00f" } ], @@ -10798,17 +10798,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -10816,14 +10816,14 @@ { "DuckDB": "9bb8e9bdc03c6262fc0b887e", "None": "9bb8e9bdc03c6262fc0b887e", -"bigquery": "9bb8e9bdc03c6262fc0b887e", +"bigquery": "67d251c042daee0bb2bf7351", "databricks": "9bb8e9bdc03c6262fc0b887e", "duckdb": "9bb8e9bdc03c6262fc0b887e", "generic": "9bb8e9bdc03c6262fc0b887e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9bb8e9bdc03c6262fc0b887e", -"postgres": "9bb8e9bdc03c6262fc0b887e", -"postgresql": "9bb8e9bdc03c6262fc0b887e", +"motherduck": "9bb8e9bdc03c6262fc0b887e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f2ce9dc78f83119cd19850e3", +"postgresql": "f2ce9dc78f83119cd19850e3", "snowflake": "9bb8e9bdc03c6262fc0b887e", "tsql": "9bb8e9bdc03c6262fc0b887e" } @@ -10832,17 +10832,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -10850,14 +10850,14 @@ { "DuckDB": "b69a57be16780e0a5e4acadb", "None": "b69a57be16780e0a5e4acadb", -"bigquery": "b69a57be16780e0a5e4acadb", +"bigquery": "67d251c042daee0bb2bf7351", "databricks": "b69a57be16780e0a5e4acadb", "duckdb": "b69a57be16780e0a5e4acadb", "generic": "b69a57be16780e0a5e4acadb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b69a57be16780e0a5e4acadb", -"postgres": "b69a57be16780e0a5e4acadb", -"postgresql": "b69a57be16780e0a5e4acadb", +"motherduck": "b69a57be16780e0a5e4acadb", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a7d1c1767c3d4e900c7d3cb4", +"postgresql": "a7d1c1767c3d4e900c7d3cb4", "snowflake": "b69a57be16780e0a5e4acadb", "tsql": "b69a57be16780e0a5e4acadb" } @@ -10871,8 +10871,8 @@ "databricks": "c703e456945a8f06d005c98b", "duckdb": "c703e456945a8f06d005c98b", "generic": "c703e456945a8f06d005c98b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c703e456945a8f06d005c98b", +"motherduck": "c703e456945a8f06d005c98b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c703e456945a8f06d005c98b", "postgresql": "c703e456945a8f06d005c98b", "snowflake": "c703e456945a8f06d005c98b", @@ -10888,8 +10888,8 @@ "databricks": "8371f7fd8d5afa0c7c86482b", "duckdb": "8371f7fd8d5afa0c7c86482b", "generic": "8371f7fd8d5afa0c7c86482b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8371f7fd8d5afa0c7c86482b", +"motherduck": "8371f7fd8d5afa0c7c86482b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8371f7fd8d5afa0c7c86482b", "postgresql": "8371f7fd8d5afa0c7c86482b", "snowflake": "8371f7fd8d5afa0c7c86482b", @@ -10905,10 +10905,10 @@ "databricks": "f4fc387af06ec14d0ed37c37", "duckdb": "f4fc387af06ec14d0ed37c37", "generic": "f4fc387af06ec14d0ed37c37", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f4fc387af06ec14d0ed37c37", -"postgres": "f4fc387af06ec14d0ed37c37", -"postgresql": "f4fc387af06ec14d0ed37c37", +"motherduck": "f4fc387af06ec14d0ed37c37", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "6e561b85b14713ee50331da1", +"postgresql": "6e561b85b14713ee50331da1", "snowflake": "f4fc387af06ec14d0ed37c37", "tsql": "f4fc387af06ec14d0ed37c37" } @@ -10922,8 +10922,8 @@ "databricks": "97a92f4a47efe38678dac07f", "duckdb": "97a92f4a47efe38678dac07f", "generic": "97a92f4a47efe38678dac07f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "97a92f4a47efe38678dac07f", +"motherduck": "97a92f4a47efe38678dac07f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "97a92f4a47efe38678dac07f", "postgresql": "97a92f4a47efe38678dac07f", "snowflake": "97a92f4a47efe38678dac07f", @@ -10939,8 +10939,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -10956,8 +10956,8 @@ "databricks": "c6889f2965db73017be6f6e7", "duckdb": "c6889f2965db73017be6f6e7", "generic": "c6889f2965db73017be6f6e7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6889f2965db73017be6f6e7", +"motherduck": "c6889f2965db73017be6f6e7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6889f2965db73017be6f6e7", "postgresql": "c6889f2965db73017be6f6e7", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -10973,10 +10973,10 @@ "databricks": "279ea7f6f6a3910de04b795b", "duckdb": "279ea7f6f6a3910de04b795b", "generic": "279ea7f6f6a3910de04b795b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "279ea7f6f6a3910de04b795b", -"postgres": "279ea7f6f6a3910de04b795b", -"postgresql": "279ea7f6f6a3910de04b795b", +"motherduck": "279ea7f6f6a3910de04b795b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "bc520aebd5872e40030ec7d9", +"postgresql": "bc520aebd5872e40030ec7d9", "snowflake": "279ea7f6f6a3910de04b795b", "tsql": "279ea7f6f6a3910de04b795b" } @@ -10986,12 +10986,12 @@ { "DuckDB": "04f0b885283ff5fc129874ad", "None": "04f0b885283ff5fc129874ad", -"bigquery": "04f0b885283ff5fc129874ad", +"bigquery": "e1c1429838b93039324a47f3", "databricks": "04f0b885283ff5fc129874ad", "duckdb": "04f0b885283ff5fc129874ad", "generic": "04f0b885283ff5fc129874ad", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "04f0b885283ff5fc129874ad", +"motherduck": "04f0b885283ff5fc129874ad", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "04f0b885283ff5fc129874ad", "postgresql": "04f0b885283ff5fc129874ad", "snowflake": "04f0b885283ff5fc129874ad", @@ -11001,14 +11001,14 @@ [ "type", { -"DuckDB": "c6654395c62d21b415299f72", +"DuckDB": "0712c33a016f7dd6a37ee011", "None": "c6654395c62d21b415299f72", "bigquery": "0712c33a016f7dd6a37ee011", "databricks": "c6654395c62d21b415299f72", -"duckdb": "c6654395c62d21b415299f72", +"duckdb": "0712c33a016f7dd6a37ee011", "generic": "c6654395c62d21b415299f72", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2978a8fe925c7f93c6e9fcfb", +"motherduck": "0712c33a016f7dd6a37ee011", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6654395c62d21b415299f72", "postgresql": "c6654395c62d21b415299f72", "snowflake": "0712c33a016f7dd6a37ee011", @@ -11019,17 +11019,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -11041,8 +11041,8 @@ "databricks": "93c1b5b5960e26479baf88d0", "duckdb": "93c1b5b5960e26479baf88d0", "generic": "93c1b5b5960e26479baf88d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "93c1b5b5960e26479baf88d0", +"motherduck": "93c1b5b5960e26479baf88d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "93c1b5b5960e26479baf88d0", "postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "93c1b5b5960e26479baf88d0", @@ -11058,8 +11058,8 @@ "databricks": "6a912271e85e6d85c1238bc0", "duckdb": "6a912271e85e6d85c1238bc0", "generic": "6a912271e85e6d85c1238bc0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6a912271e85e6d85c1238bc0", +"motherduck": "6a912271e85e6d85c1238bc0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6a912271e85e6d85c1238bc0", "postgresql": "6a912271e85e6d85c1238bc0", "snowflake": "6a912271e85e6d85c1238bc0", @@ -11075,8 +11075,8 @@ "databricks": "5abf4ec799a2ec32fb10da7e", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5abf4ec799a2ec32fb10da7e", "postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -11092,10 +11092,10 @@ "databricks": "eea9a25a6fbf8e049a445513", "duckdb": "eea9a25a6fbf8e049a445513", "generic": "eea9a25a6fbf8e049a445513", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "eea9a25a6fbf8e049a445513", -"postgres": "eea9a25a6fbf8e049a445513", -"postgresql": "eea9a25a6fbf8e049a445513", +"motherduck": "eea9a25a6fbf8e049a445513", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "769f762f4c7cffb2990ddacb", +"postgresql": "769f762f4c7cffb2990ddacb", "snowflake": "eea9a25a6fbf8e049a445513", "tsql": "eea9a25a6fbf8e049a445513" } @@ -11109,8 +11109,8 @@ "databricks": "304be1d51ad99bfab3750f57", "duckdb": "304be1d51ad99bfab3750f57", "generic": "304be1d51ad99bfab3750f57", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "304be1d51ad99bfab3750f57", +"motherduck": "304be1d51ad99bfab3750f57", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "304be1d51ad99bfab3750f57", "postgresql": "304be1d51ad99bfab3750f57", "snowflake": "304be1d51ad99bfab3750f57", @@ -11126,8 +11126,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -11143,8 +11143,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -11160,8 +11160,8 @@ "databricks": "5d0a19a893dbf0c1e6e9f15c", "duckdb": "5d0a19a893dbf0c1e6e9f15c", "generic": "5d0a19a893dbf0c1e6e9f15c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d0a19a893dbf0c1e6e9f15c", +"motherduck": "5d0a19a893dbf0c1e6e9f15c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5d0a19a893dbf0c1e6e9f15c", "postgresql": "5d0a19a893dbf0c1e6e9f15c", "snowflake": "5d0a19a893dbf0c1e6e9f15c", @@ -11173,14 +11173,14 @@ { "DuckDB": "9bb8e9bdc03c6262fc0b887e", "None": "9bb8e9bdc03c6262fc0b887e", -"bigquery": "9bb8e9bdc03c6262fc0b887e", +"bigquery": "67d251c042daee0bb2bf7351", "databricks": "9bb8e9bdc03c6262fc0b887e", "duckdb": "9bb8e9bdc03c6262fc0b887e", "generic": "9bb8e9bdc03c6262fc0b887e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9bb8e9bdc03c6262fc0b887e", -"postgres": "9bb8e9bdc03c6262fc0b887e", -"postgresql": "9bb8e9bdc03c6262fc0b887e", +"motherduck": "9bb8e9bdc03c6262fc0b887e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f2ce9dc78f83119cd19850e3", +"postgresql": "f2ce9dc78f83119cd19850e3", "snowflake": "9bb8e9bdc03c6262fc0b887e", "tsql": "9bb8e9bdc03c6262fc0b887e" } @@ -11194,8 +11194,8 @@ "databricks": "15f0b4e032d5524678c61cae", "duckdb": "15f0b4e032d5524678c61cae", "generic": "15f0b4e032d5524678c61cae", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "15f0b4e032d5524678c61cae", +"motherduck": "15f0b4e032d5524678c61cae", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "15f0b4e032d5524678c61cae", "postgresql": "15f0b4e032d5524678c61cae", "snowflake": "15f0b4e032d5524678c61cae", @@ -11211,8 +11211,8 @@ "databricks": "cafb5cff5526dd419baad0ed", "duckdb": "cafb5cff5526dd419baad0ed", "generic": "cafb5cff5526dd419baad0ed", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cafb5cff5526dd419baad0ed", +"motherduck": "cafb5cff5526dd419baad0ed", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cafb5cff5526dd419baad0ed", "postgresql": "cafb5cff5526dd419baad0ed", "snowflake": "cafb5cff5526dd419baad0ed", @@ -11228,8 +11228,8 @@ "databricks": "8a3f094f18fb4047f0febf59", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "8a3f094f18fb4047f0febf59", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8a3f094f18fb4047f0febf59", "postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "850deea990b52b82b36a9848", @@ -11245,10 +11245,10 @@ "databricks": "bf5a83d0c02f8890941c7ec8", "duckdb": "bf5a83d0c02f8890941c7ec8", "generic": "bf5a83d0c02f8890941c7ec8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "bf5a83d0c02f8890941c7ec8", -"postgres": "bf5a83d0c02f8890941c7ec8", -"postgresql": "bf5a83d0c02f8890941c7ec8", +"motherduck": "bf5a83d0c02f8890941c7ec8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ef750421d1e193fa61992c79", +"postgresql": "ef750421d1e193fa61992c79", "snowflake": "bf5a83d0c02f8890941c7ec8", "tsql": "bf5a83d0c02f8890941c7ec8" } @@ -11257,15 +11257,15 @@ "type", { "DuckDB": "4c16382f7ad617ac3cbfa833", -"None": "0f63c150afc0bb5bbf7763ba", -"bigquery": "a4d165ed06d0b1b815192ef4", -"databricks": "0f63c150afc0bb5bbf7763ba", +"None": "accf46359aa8c74483b9a197", +"bigquery": "accf46359aa8c74483b9a197", +"databricks": "accf46359aa8c74483b9a197", "duckdb": "4c16382f7ad617ac3cbfa833", -"generic": "0f63c150afc0bb5bbf7763ba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "4c16382f7ad617ac3cbfa833", -"postgresql": "4c16382f7ad617ac3cbfa833", +"generic": "accf46359aa8c74483b9a197", +"motherduck": "4c16382f7ad617ac3cbfa833", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "accf46359aa8c74483b9a197", +"postgresql": "accf46359aa8c74483b9a197", "snowflake": "303d6e0feaedc557ea64e414", "tsql": "accf46359aa8c74483b9a197" } @@ -11274,17 +11274,17 @@ "type", { "DuckDB": "f2ed52f6bf46b4db9343551c", -"None": "f2ed52f6bf46b4db9343551c", -"bigquery": "f10bdd4d40eb495cbcecd31d", -"databricks": "f2ed52f6bf46b4db9343551c", +"None": "3f998a9ab68d8b2514840489", +"bigquery": "1e75e5227bea0ae294ac7af1", +"databricks": "3f998a9ab68d8b2514840489", "duckdb": "f2ed52f6bf46b4db9343551c", -"generic": "f2ed52f6bf46b4db9343551c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f2ed52f6bf46b4db9343551c", -"postgres": "f2ed52f6bf46b4db9343551c", -"postgresql": "f2ed52f6bf46b4db9343551c", +"generic": "3f998a9ab68d8b2514840489", +"motherduck": "f2ed52f6bf46b4db9343551c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3f998a9ab68d8b2514840489", +"postgresql": "3f998a9ab68d8b2514840489", "snowflake": "f2ed52f6bf46b4db9343551c", -"tsql": "f2ed52f6bf46b4db9343551c" +"tsql": "3f998a9ab68d8b2514840489" } ], [ @@ -11292,14 +11292,14 @@ { "DuckDB": "c84c0b1d4d7caa6744130456", "None": "c84c0b1d4d7caa6744130456", -"bigquery": "c84c0b1d4d7caa6744130456", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "c84c0b1d4d7caa6744130456", "duckdb": "c84c0b1d4d7caa6744130456", "generic": "c84c0b1d4d7caa6744130456", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c84c0b1d4d7caa6744130456", -"postgres": "c84c0b1d4d7caa6744130456", -"postgresql": "c84c0b1d4d7caa6744130456", +"motherduck": "c84c0b1d4d7caa6744130456", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "725c73e74f311417bb4f95e8", +"postgresql": "725c73e74f311417bb4f95e8", "snowflake": "c84c0b1d4d7caa6744130456", "tsql": "c84c0b1d4d7caa6744130456" } @@ -11309,14 +11309,14 @@ { "DuckDB": "aea8a680fa18770e56bf6220", "None": "aea8a680fa18770e56bf6220", -"bigquery": "aea8a680fa18770e56bf6220", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "aea8a680fa18770e56bf6220", "duckdb": "aea8a680fa18770e56bf6220", "generic": "aea8a680fa18770e56bf6220", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aea8a680fa18770e56bf6220", -"postgres": "aea8a680fa18770e56bf6220", -"postgresql": "aea8a680fa18770e56bf6220", +"motherduck": "aea8a680fa18770e56bf6220", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "836641bf4537dec3e767931d", +"postgresql": "836641bf4537dec3e767931d", "snowflake": "aea8a680fa18770e56bf6220", "tsql": "aea8a680fa18770e56bf6220" } @@ -11330,10 +11330,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -11347,8 +11347,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -11364,8 +11364,8 @@ "databricks": "5aa51d84ac5e6c7a9306f348", "duckdb": "5aa51d84ac5e6c7a9306f348", "generic": "5aa51d84ac5e6c7a9306f348", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5aa51d84ac5e6c7a9306f348", +"motherduck": "5aa51d84ac5e6c7a9306f348", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5aa51d84ac5e6c7a9306f348", "postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "5aa51d84ac5e6c7a9306f348", @@ -11381,8 +11381,8 @@ "databricks": "70fb4728c3adcf6dbe4975d5", "duckdb": "70fb4728c3adcf6dbe4975d5", "generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", @@ -11398,8 +11398,8 @@ "databricks": "dcb00b7053ffe69fe3ce99cd", "duckdb": "c7b697bbfa82dd2821ad64e9", "generic": "c7b697bbfa82dd2821ad64e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "dcb00b7053ffe69fe3ce99cd", +"motherduck": "c7b697bbfa82dd2821ad64e9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c7b697bbfa82dd2821ad64e9", "postgresql": "c7b697bbfa82dd2821ad64e9", "snowflake": "c7b697bbfa82dd2821ad64e9", @@ -11415,8 +11415,8 @@ "databricks": "c0b12bfc586282ce5ea85c45", "duckdb": "c0b12bfc586282ce5ea85c45", "generic": "c0b12bfc586282ce5ea85c45", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c0b12bfc586282ce5ea85c45", +"motherduck": "c0b12bfc586282ce5ea85c45", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c0b12bfc586282ce5ea85c45", "postgresql": "c0b12bfc586282ce5ea85c45", "snowflake": "c0b12bfc586282ce5ea85c45", @@ -11432,8 +11432,8 @@ "databricks": "806bf4b6d83b5dc9948e2054", "duckdb": "806bf4b6d83b5dc9948e2054", "generic": "806bf4b6d83b5dc9948e2054", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "806bf4b6d83b5dc9948e2054", +"motherduck": "806bf4b6d83b5dc9948e2054", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "806bf4b6d83b5dc9948e2054", "postgresql": "806bf4b6d83b5dc9948e2054", "snowflake": "806bf4b6d83b5dc9948e2054", @@ -11449,10 +11449,10 @@ "databricks": "871969531da28b86361e65d2", "duckdb": "871969531da28b86361e65d2", "generic": "871969531da28b86361e65d2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "871969531da28b86361e65d2", -"postgres": "871969531da28b86361e65d2", -"postgresql": "871969531da28b86361e65d2", +"motherduck": "871969531da28b86361e65d2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "990e37f96d40e397fe74978c", +"postgresql": "990e37f96d40e397fe74978c", "snowflake": "871969531da28b86361e65d2", "tsql": "871969531da28b86361e65d2" } @@ -11466,8 +11466,8 @@ "databricks": "4129901e0f313b38452e22af", "duckdb": "4129901e0f313b38452e22af", "generic": "4129901e0f313b38452e22af", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4129901e0f313b38452e22af", +"motherduck": "4129901e0f313b38452e22af", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4129901e0f313b38452e22af", "postgresql": "4129901e0f313b38452e22af", "snowflake": "4129901e0f313b38452e22af", @@ -11483,8 +11483,8 @@ "databricks": "0c290c40483b9651ff557830", "duckdb": "0c290c40483b9651ff557830", "generic": "0c290c40483b9651ff557830", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0c290c40483b9651ff557830", +"motherduck": "0c290c40483b9651ff557830", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0c290c40483b9651ff557830", "postgresql": "0c290c40483b9651ff557830", "snowflake": "0c290c40483b9651ff557830", @@ -11500,8 +11500,8 @@ "databricks": "b1603277660bbe23982ff72a", "duckdb": "b0505024b3f15f191c70a470", "generic": "b1603277660bbe23982ff72a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "b0505024b3f15f191c70a470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fa1a8787c8f69b9f9be89526", "postgresql": "fa1a8787c8f69b9f9be89526", "snowflake": "50404426183626ce7b686f80", @@ -11517,8 +11517,8 @@ "databricks": "b63494be71c6c8936f6824a6", "duckdb": "b63494be71c6c8936f6824a6", "generic": "b63494be71c6c8936f6824a6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b63494be71c6c8936f6824a6", +"motherduck": "b63494be71c6c8936f6824a6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b63494be71c6c8936f6824a6", "postgresql": "b63494be71c6c8936f6824a6", "snowflake": "b63494be71c6c8936f6824a6", @@ -11534,8 +11534,8 @@ "databricks": "016c25f8f0c58947f8da9152", "duckdb": "016c25f8f0c58947f8da9152", "generic": "016c25f8f0c58947f8da9152", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "016c25f8f0c58947f8da9152", +"motherduck": "016c25f8f0c58947f8da9152", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "016c25f8f0c58947f8da9152", "postgresql": "016c25f8f0c58947f8da9152", "snowflake": "016c25f8f0c58947f8da9152", @@ -11551,8 +11551,8 @@ "databricks": "e02779be57c0fcfa69ee7746", "duckdb": "e02779be57c0fcfa69ee7746", "generic": "e02779be57c0fcfa69ee7746", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e02779be57c0fcfa69ee7746", +"motherduck": "e02779be57c0fcfa69ee7746", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e02779be57c0fcfa69ee7746", "postgresql": "e02779be57c0fcfa69ee7746", "snowflake": "e02779be57c0fcfa69ee7746", @@ -11568,8 +11568,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "ace891b6844cb59efad42031", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "ace891b6844cb59efad42031", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -11585,8 +11585,8 @@ "databricks": "b7507b03866507106687a313", "duckdb": "b7507b03866507106687a313", "generic": "b7507b03866507106687a313", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b7507b03866507106687a313", +"motherduck": "b7507b03866507106687a313", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b7507b03866507106687a313", "postgresql": "b7507b03866507106687a313", "snowflake": "b7507b03866507106687a313", @@ -11602,10 +11602,10 @@ "databricks": "fdc9a2fc03f4b67d24982d0a", "duckdb": "fdc9a2fc03f4b67d24982d0a", "generic": "fdc9a2fc03f4b67d24982d0a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fdc9a2fc03f4b67d24982d0a", -"postgres": "fdc9a2fc03f4b67d24982d0a", -"postgresql": "fdc9a2fc03f4b67d24982d0a", +"motherduck": "fdc9a2fc03f4b67d24982d0a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "576eb7ad8e7eca2db50ec386", +"postgresql": "576eb7ad8e7eca2db50ec386", "snowflake": "fdc9a2fc03f4b67d24982d0a", "tsql": "fdc9a2fc03f4b67d24982d0a" } @@ -11614,17 +11614,17 @@ "type", { "DuckDB": "5c8b98f516cedefc237fa721", -"None": "5c8b98f516cedefc237fa721", -"bigquery": "5c8b98f516cedefc237fa721", -"databricks": "5c8b98f516cedefc237fa721", +"None": "81a45386abae5f6be0a027d0", +"bigquery": "09b7f1f9111bc2e0767cc059", +"databricks": "81a45386abae5f6be0a027d0", "duckdb": "5c8b98f516cedefc237fa721", -"generic": "5c8b98f516cedefc237fa721", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c8b98f516cedefc237fa721", +"generic": "81a45386abae5f6be0a027d0", +"motherduck": "5c8b98f516cedefc237fa721", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5c8b98f516cedefc237fa721", "postgresql": "5c8b98f516cedefc237fa721", "snowflake": "5c8b98f516cedefc237fa721", -"tsql": "5c8b98f516cedefc237fa721" +"tsql": "81a45386abae5f6be0a027d0" } ], [ @@ -11636,8 +11636,8 @@ "databricks": "8d26a44bbe0d29bdb1509369", "duckdb": "27d7e27586eab431e308413f", "generic": "8d26a44bbe0d29bdb1509369", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8d26a44bbe0d29bdb1509369", +"motherduck": "27d7e27586eab431e308413f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8d26a44bbe0d29bdb1509369", "postgresql": "8d26a44bbe0d29bdb1509369", "snowflake": "8d26a44bbe0d29bdb1509369", @@ -11653,8 +11653,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -11670,8 +11670,8 @@ "databricks": "ab5ad6180652b3b00d1f5b01", "duckdb": "ab5ad6180652b3b00d1f5b01", "generic": "ab5ad6180652b3b00d1f5b01", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ab5ad6180652b3b00d1f5b01", +"motherduck": "ab5ad6180652b3b00d1f5b01", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ab5ad6180652b3b00d1f5b01", "postgresql": "ab5ad6180652b3b00d1f5b01", "snowflake": "f43dac38f34a1c0618a3f812", @@ -11687,8 +11687,8 @@ "databricks": "4662a1758442ce44b830269f", "duckdb": "4662a1758442ce44b830269f", "generic": "4662a1758442ce44b830269f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4662a1758442ce44b830269f", +"motherduck": "4662a1758442ce44b830269f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4662a1758442ce44b830269f", "postgresql": "4662a1758442ce44b830269f", "snowflake": "4662a1758442ce44b830269f", @@ -11704,8 +11704,8 @@ "databricks": "34af912a178427fc6e8bdee3", "duckdb": "34af912a178427fc6e8bdee3", "generic": "34af912a178427fc6e8bdee3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "34af912a178427fc6e8bdee3", +"motherduck": "34af912a178427fc6e8bdee3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "34af912a178427fc6e8bdee3", "postgresql": "34af912a178427fc6e8bdee3", "snowflake": "34af912a178427fc6e8bdee3", @@ -11721,8 +11721,8 @@ "databricks": "29e896ae6f2844ec3744aad6", "duckdb": "27d7e27586eab431e308413f", "generic": "29e896ae6f2844ec3744aad6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "29e896ae6f2844ec3744aad6", +"motherduck": "27d7e27586eab431e308413f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "29e896ae6f2844ec3744aad6", "postgresql": "29e896ae6f2844ec3744aad6", "snowflake": "29e896ae6f2844ec3744aad6", @@ -11738,8 +11738,8 @@ "databricks": "e8605878c6fffc044556a858", "duckdb": "e8605878c6fffc044556a858", "generic": "e8605878c6fffc044556a858", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e8605878c6fffc044556a858", +"motherduck": "e8605878c6fffc044556a858", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8605878c6fffc044556a858", "postgresql": "e8605878c6fffc044556a858", "snowflake": "e8605878c6fffc044556a858", @@ -11751,14 +11751,14 @@ { "DuckDB": "b561884132dbe7e42b719110", "None": "b561884132dbe7e42b719110", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "b561884132dbe7e42b719110", "duckdb": "b561884132dbe7e42b719110", "generic": "b561884132dbe7e42b719110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b561884132dbe7e42b719110", -"postgres": "b561884132dbe7e42b719110", -"postgresql": "b561884132dbe7e42b719110", +"motherduck": "b561884132dbe7e42b719110", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5aa51d84ac5e6c7a9306f348", +"postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "b561884132dbe7e42b719110", "tsql": "b561884132dbe7e42b719110" } @@ -11772,10 +11772,10 @@ "databricks": "c6106f30f23f392e17eadef4", "duckdb": "c6106f30f23f392e17eadef4", "generic": "c6106f30f23f392e17eadef4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6106f30f23f392e17eadef4", -"postgres": "c6106f30f23f392e17eadef4", -"postgresql": "c6106f30f23f392e17eadef4", +"motherduck": "c6106f30f23f392e17eadef4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f43dac38f34a1c0618a3f812", +"postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "c6106f30f23f392e17eadef4", "tsql": "c6106f30f23f392e17eadef4" } @@ -11789,8 +11789,8 @@ "databricks": "e7aec8198ab628519324444a", "duckdb": "e7aec8198ab628519324444a", "generic": "e7aec8198ab628519324444a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e7aec8198ab628519324444a", +"motherduck": "e7aec8198ab628519324444a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e7aec8198ab628519324444a", "postgresql": "e7aec8198ab628519324444a", "snowflake": "e7aec8198ab628519324444a", @@ -11802,14 +11802,14 @@ { "DuckDB": "881106a4a0d2de0ff7c56373", "None": "881106a4a0d2de0ff7c56373", -"bigquery": "881106a4a0d2de0ff7c56373", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "881106a4a0d2de0ff7c56373", "duckdb": "881106a4a0d2de0ff7c56373", "generic": "881106a4a0d2de0ff7c56373", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "881106a4a0d2de0ff7c56373", -"postgres": "881106a4a0d2de0ff7c56373", -"postgresql": "881106a4a0d2de0ff7c56373", +"motherduck": "881106a4a0d2de0ff7c56373", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "cf167ec395fc843602e3b1e0", +"postgresql": "cf167ec395fc843602e3b1e0", "snowflake": "881106a4a0d2de0ff7c56373", "tsql": "881106a4a0d2de0ff7c56373" } @@ -11823,10 +11823,10 @@ "databricks": "2c6b371b030464f525066893", "duckdb": "2c6b371b030464f525066893", "generic": "2c6b371b030464f525066893", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2c6b371b030464f525066893", -"postgres": "2c6b371b030464f525066893", -"postgresql": "2c6b371b030464f525066893", +"motherduck": "2c6b371b030464f525066893", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3feb479faeec777c2ade8afd", +"postgresql": "3feb479faeec777c2ade8afd", "snowflake": "2c6b371b030464f525066893", "tsql": "2c6b371b030464f525066893" } @@ -11837,11 +11837,11 @@ "DuckDB": "e3d9a113277b9c69432b32d1", "None": "e3d9a113277b9c69432b32d1", "bigquery": "e3d9a113277b9c69432b32d1", -"databricks": "4cda99191af9adfbe91e70f6", +"databricks": "e3d9a113277b9c69432b32d1", "duckdb": "e3d9a113277b9c69432b32d1", "generic": "e3d9a113277b9c69432b32d1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4cda99191af9adfbe91e70f6", +"motherduck": "e3d9a113277b9c69432b32d1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e3d9a113277b9c69432b32d1", "postgresql": "e3d9a113277b9c69432b32d1", "snowflake": "e3d9a113277b9c69432b32d1", @@ -11857,8 +11857,8 @@ "databricks": "ba0da7ef018b990fcc83cba1", "duckdb": "ba0da7ef018b990fcc83cba1", "generic": "ba0da7ef018b990fcc83cba1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ba0da7ef018b990fcc83cba1", +"motherduck": "ba0da7ef018b990fcc83cba1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ba0da7ef018b990fcc83cba1", "postgresql": "ba0da7ef018b990fcc83cba1", "snowflake": "ba0da7ef018b990fcc83cba1", @@ -11874,10 +11874,10 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "396b2ce32efb5365b393c230", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", -"postgres": "e57ac1541fb51b362cd5b470", -"postgresql": "e57ac1541fb51b362cd5b470", +"motherduck": "396b2ce32efb5365b393c230", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "396b2ce32efb5365b393c230", +"postgresql": "396b2ce32efb5365b393c230", "snowflake": "4b356542044f1267fcfc487a", "tsql": "e57ac1541fb51b362cd5b470" } @@ -11886,17 +11886,17 @@ "type", { "DuckDB": "5abf4ec799a2ec32fb10da7e", -"None": "5abf4ec799a2ec32fb10da7e", +"None": "de89632e277dbc8c97115419", "bigquery": "5abf4ec799a2ec32fb10da7e", -"databricks": "5abf4ec799a2ec32fb10da7e", +"databricks": "de89632e277dbc8c97115419", "duckdb": "5abf4ec799a2ec32fb10da7e", -"generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", +"generic": "de89632e277dbc8c97115419", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5abf4ec799a2ec32fb10da7e", "postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "a5656d70e208254d1d3e9b4f", -"tsql": "5abf4ec799a2ec32fb10da7e" +"tsql": "de89632e277dbc8c97115419" } ], [ @@ -11908,8 +11908,8 @@ "databricks": "319a9fbb02ed503eb114164b", "duckdb": "e060b5a5a8e9774b580d58d3", "generic": "e060b5a5a8e9774b580d58d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "319a9fbb02ed503eb114164b", +"motherduck": "e060b5a5a8e9774b580d58d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e060b5a5a8e9774b580d58d3", "postgresql": "e060b5a5a8e9774b580d58d3", "snowflake": "e060b5a5a8e9774b580d58d3", @@ -11925,8 +11925,8 @@ "databricks": "67d251c042daee0bb2bf7351", "duckdb": "67d251c042daee0bb2bf7351", "generic": "67d251c042daee0bb2bf7351", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "67d251c042daee0bb2bf7351", +"motherduck": "67d251c042daee0bb2bf7351", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "67d251c042daee0bb2bf7351", "postgresql": "67d251c042daee0bb2bf7351", "snowflake": "67d251c042daee0bb2bf7351", @@ -11937,17 +11937,17 @@ "type", { "DuckDB": "919b7ec6a7b49d8527b784cd", -"None": "919b7ec6a7b49d8527b784cd", -"bigquery": "204206d1d1eecf007966cc5b", -"databricks": "e3bc1b8bad22d8104417b00f", +"None": "558da38ec4d9d5d6c72f60cf", +"bigquery": "c50a316d091c821866e4bfba", +"databricks": "558da38ec4d9d5d6c72f60cf", "duckdb": "919b7ec6a7b49d8527b784cd", -"generic": "919b7ec6a7b49d8527b784cd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "919b7ec6a7b49d8527b784cd", -"postgres": "a3b6b25265be330ec52a3322", -"postgresql": "a3b6b25265be330ec52a3322", +"generic": "558da38ec4d9d5d6c72f60cf", +"motherduck": "919b7ec6a7b49d8527b784cd", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "558da38ec4d9d5d6c72f60cf", +"postgresql": "558da38ec4d9d5d6c72f60cf", "snowflake": "919b7ec6a7b49d8527b784cd", -"tsql": "919b7ec6a7b49d8527b784cd" +"tsql": "558da38ec4d9d5d6c72f60cf" } ], [ @@ -11959,8 +11959,8 @@ "databricks": "66ee8490513ef7b131cb4824", "duckdb": "66ee8490513ef7b131cb4824", "generic": "66ee8490513ef7b131cb4824", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "66ee8490513ef7b131cb4824", +"motherduck": "66ee8490513ef7b131cb4824", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "66ee8490513ef7b131cb4824", "postgresql": "66ee8490513ef7b131cb4824", "snowflake": "66ee8490513ef7b131cb4824", @@ -11976,8 +11976,8 @@ "databricks": "8f552eefca3955a73672f686", "duckdb": "8f552eefca3955a73672f686", "generic": "8f552eefca3955a73672f686", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8f552eefca3955a73672f686", +"motherduck": "8f552eefca3955a73672f686", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8f552eefca3955a73672f686", "postgresql": "8f552eefca3955a73672f686", "snowflake": "8f552eefca3955a73672f686", @@ -11993,10 +11993,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -12010,8 +12010,8 @@ "databricks": "5abf4ec799a2ec32fb10da7e", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5abf4ec799a2ec32fb10da7e", "postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -12027,10 +12027,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -12044,8 +12044,8 @@ "databricks": "853d4786e4edb4f90284765b", "duckdb": "f4c37736a388a1d793d4de1a", "generic": "853d4786e4edb4f90284765b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "f4c37736a388a1d793d4de1a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f4c37736a388a1d793d4de1a", "postgresql": "f4c37736a388a1d793d4de1a", "snowflake": "a640dde3e800eb6ea27813e3", @@ -12061,8 +12061,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -12073,17 +12073,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -12091,14 +12091,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -12112,8 +12112,8 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "19a1a80ffc06169f32694de8", "postgresql": "19a1a80ffc06169f32694de8", "snowflake": "19a1a80ffc06169f32694de8", @@ -12125,14 +12125,14 @@ { "DuckDB": "776e4bf23c8ef10ffaceade2", "None": "776e4bf23c8ef10ffaceade2", -"bigquery": "776e4bf23c8ef10ffaceade2", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "776e4bf23c8ef10ffaceade2", "duckdb": "776e4bf23c8ef10ffaceade2", "generic": "776e4bf23c8ef10ffaceade2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "776e4bf23c8ef10ffaceade2", -"postgres": "776e4bf23c8ef10ffaceade2", -"postgresql": "776e4bf23c8ef10ffaceade2", +"motherduck": "776e4bf23c8ef10ffaceade2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5d06b10843e3e6487fb9906a", +"postgresql": "5d06b10843e3e6487fb9906a", "snowflake": "776e4bf23c8ef10ffaceade2", "tsql": "776e4bf23c8ef10ffaceade2" } @@ -12146,8 +12146,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -12163,10 +12163,10 @@ "databricks": "a3acd7ba35e81a800f967bd3", "duckdb": "42d4a23d9a52e79d0c3458d3", "generic": "a3acd7ba35e81a800f967bd3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a3acd7ba35e81a800f967bd3", -"postgres": "a3acd7ba35e81a800f967bd3", -"postgresql": "a3acd7ba35e81a800f967bd3", +"motherduck": "42d4a23d9a52e79d0c3458d3", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "42d4a23d9a52e79d0c3458d3", +"postgresql": "42d4a23d9a52e79d0c3458d3", "snowflake": "a3acd7ba35e81a800f967bd3", "tsql": "a3acd7ba35e81a800f967bd3" } @@ -12176,14 +12176,14 @@ { "DuckDB": "95050a5e73c2bff179a785b7", "None": "95050a5e73c2bff179a785b7", -"bigquery": "95050a5e73c2bff179a785b7", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "95050a5e73c2bff179a785b7", "duckdb": "95050a5e73c2bff179a785b7", "generic": "95050a5e73c2bff179a785b7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "95050a5e73c2bff179a785b7", -"postgres": "95050a5e73c2bff179a785b7", -"postgresql": "95050a5e73c2bff179a785b7", +"motherduck": "95050a5e73c2bff179a785b7", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e197cb69fc5e5754a25d4038", +"postgresql": "e197cb69fc5e5754a25d4038", "snowflake": "95050a5e73c2bff179a785b7", "tsql": "95050a5e73c2bff179a785b7" } @@ -12197,8 +12197,8 @@ "databricks": "0703bf71a54942bdaa28406e", "duckdb": "0703bf71a54942bdaa28406e", "generic": "0703bf71a54942bdaa28406e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0703bf71a54942bdaa28406e", +"motherduck": "0703bf71a54942bdaa28406e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0703bf71a54942bdaa28406e", "postgresql": "0703bf71a54942bdaa28406e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -12208,17 +12208,17 @@ [ "type", { -"DuckDB": "89cc3662f602a13aef39eb80", -"None": "f2bbf59a9c02f59ca89e66b6", -"bigquery": "f2bbf59a9c02f59ca89e66b6", -"databricks": "f2bbf59a9c02f59ca89e66b6", -"duckdb": "89cc3662f602a13aef39eb80", -"generic": "f2bbf59a9c02f59ca89e66b6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "89cc3662f602a13aef39eb80", -"postgresql": "89cc3662f602a13aef39eb80", -"snowflake": "6f88ef12d95c26bf8f0bd9e5", +"DuckDB": "01e3dfc024c37a8d62c7f810", +"None": "3a4d8bca5124769db23a43df", +"bigquery": "3a4d8bca5124769db23a43df", +"databricks": "3a4d8bca5124769db23a43df", +"duckdb": "01e3dfc024c37a8d62c7f810", +"generic": "3a4d8bca5124769db23a43df", +"motherduck": "01e3dfc024c37a8d62c7f810", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "01e3dfc024c37a8d62c7f810", +"postgresql": "01e3dfc024c37a8d62c7f810", +"snowflake": "db03b5ccf153c75e43846a6a", "tsql": "ffadc5a4dbb5d511f5cde8d7" } ], @@ -12227,14 +12227,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -12248,8 +12248,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -12265,8 +12265,8 @@ "databricks": "50a940812c6ed2e6dd842e74", "duckdb": "50a940812c6ed2e6dd842e74", "generic": "50a940812c6ed2e6dd842e74", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "50a940812c6ed2e6dd842e74", +"motherduck": "50a940812c6ed2e6dd842e74", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "50a940812c6ed2e6dd842e74", "postgresql": "50a940812c6ed2e6dd842e74", "snowflake": "50a940812c6ed2e6dd842e74", @@ -12282,8 +12282,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -12299,10 +12299,10 @@ "databricks": "279ea7f6f6a3910de04b795b", "duckdb": "279ea7f6f6a3910de04b795b", "generic": "279ea7f6f6a3910de04b795b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "279ea7f6f6a3910de04b795b", -"postgres": "279ea7f6f6a3910de04b795b", -"postgresql": "279ea7f6f6a3910de04b795b", +"motherduck": "279ea7f6f6a3910de04b795b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "bc520aebd5872e40030ec7d9", +"postgresql": "bc520aebd5872e40030ec7d9", "snowflake": "279ea7f6f6a3910de04b795b", "tsql": "279ea7f6f6a3910de04b795b" } @@ -12312,12 +12312,12 @@ { "DuckDB": "461923a0d34defd0c726d6e5", "None": "461923a0d34defd0c726d6e5", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "461923a0d34defd0c726d6e5", "duckdb": "461923a0d34defd0c726d6e5", "generic": "461923a0d34defd0c726d6e5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "461923a0d34defd0c726d6e5", +"motherduck": "461923a0d34defd0c726d6e5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "461923a0d34defd0c726d6e5", "postgresql": "461923a0d34defd0c726d6e5", "snowflake": "461923a0d34defd0c726d6e5", @@ -12328,17 +12328,17 @@ "type", { "DuckDB": "84fca9ac893777959cfd715c", -"None": "84fca9ac893777959cfd715c", -"bigquery": "f28a96f0eb38ad8874f6ec5d", -"databricks": "84fca9ac893777959cfd715c", +"None": "e57ac1541fb51b362cd5b470", +"bigquery": "e57ac1541fb51b362cd5b470", +"databricks": "e57ac1541fb51b362cd5b470", "duckdb": "84fca9ac893777959cfd715c", -"generic": "84fca9ac893777959cfd715c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "84fca9ac893777959cfd715c", -"postgres": "84fca9ac893777959cfd715c", -"postgresql": "84fca9ac893777959cfd715c", +"generic": "e57ac1541fb51b362cd5b470", +"motherduck": "84fca9ac893777959cfd715c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e57ac1541fb51b362cd5b470", +"postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "84fca9ac893777959cfd715c", -"tsql": "6349bc82604b762638e35788" +"tsql": "e57ac1541fb51b362cd5b470" } ], [ @@ -12350,8 +12350,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -12367,8 +12367,8 @@ "databricks": "75a99436882f66b2fdc219e5", "duckdb": "2cc8493833d5ac6046bfbfc2", "generic": "2cc8493833d5ac6046bfbfc2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2cc8493833d5ac6046bfbfc2", +"motherduck": "2cc8493833d5ac6046bfbfc2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2cc8493833d5ac6046bfbfc2", "postgresql": "2cc8493833d5ac6046bfbfc2", "snowflake": "70fb65041d155a676d8443d4", @@ -12384,8 +12384,8 @@ "databricks": "f80980deec760e5b50e05376", "duckdb": "8305d75697b54f509bbc0f53", "generic": "80723d96ed6ed21034faa9bd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f80980deec760e5b50e05376", +"motherduck": "8305d75697b54f509bbc0f53", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8305d75697b54f509bbc0f53", "postgresql": "8305d75697b54f509bbc0f53", "snowflake": "240e7de80b095b23fdb1fd92", @@ -12397,12 +12397,12 @@ { "DuckDB": "d41d40c68507f4d02e348833", "None": "d41d40c68507f4d02e348833", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "d41d40c68507f4d02e348833", "duckdb": "d41d40c68507f4d02e348833", "generic": "d41d40c68507f4d02e348833", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d41d40c68507f4d02e348833", +"motherduck": "d41d40c68507f4d02e348833", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d41d40c68507f4d02e348833", "postgresql": "d41d40c68507f4d02e348833", "snowflake": "d41d40c68507f4d02e348833", @@ -12413,17 +12413,17 @@ "type", { "DuckDB": "2c44dc35fd1ef8701101802e", -"None": "2c44dc35fd1ef8701101802e", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "2c44dc35fd1ef8701101802e", +"None": "8441d00030df06ad6a5534d3", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "8441d00030df06ad6a5534d3", "duckdb": "2c44dc35fd1ef8701101802e", -"generic": "2c44dc35fd1ef8701101802e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2c44dc35fd1ef8701101802e", -"postgres": "2c44dc35fd1ef8701101802e", -"postgresql": "2c44dc35fd1ef8701101802e", +"generic": "8441d00030df06ad6a5534d3", +"motherduck": "2c44dc35fd1ef8701101802e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8441d00030df06ad6a5534d3", +"postgresql": "8441d00030df06ad6a5534d3", "snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "2c44dc35fd1ef8701101802e" +"tsql": "8441d00030df06ad6a5534d3" } ], [ @@ -12431,14 +12431,14 @@ { "DuckDB": "599b3293ed620803ce2401b5", "None": "599b3293ed620803ce2401b5", -"bigquery": "599b3293ed620803ce2401b5", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "599b3293ed620803ce2401b5", "duckdb": "599b3293ed620803ce2401b5", "generic": "599b3293ed620803ce2401b5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "599b3293ed620803ce2401b5", -"postgres": "599b3293ed620803ce2401b5", -"postgresql": "599b3293ed620803ce2401b5", +"motherduck": "599b3293ed620803ce2401b5", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "363a6b7f05b0dac69e1e6547", +"postgresql": "363a6b7f05b0dac69e1e6547", "snowflake": "599b3293ed620803ce2401b5", "tsql": "599b3293ed620803ce2401b5" } @@ -12452,8 +12452,8 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "669084d1ea704ae5b8ee05c2", "postgresql": "669084d1ea704ae5b8ee05c2", "snowflake": "669084d1ea704ae5b8ee05c2", @@ -12469,8 +12469,8 @@ "databricks": "9e4a50a8aab648a9737f7d0c", "duckdb": "9e4a50a8aab648a9737f7d0c", "generic": "9e4a50a8aab648a9737f7d0c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9e4a50a8aab648a9737f7d0c", +"motherduck": "9e4a50a8aab648a9737f7d0c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "36d29258901a4d8c296baa68", "postgresql": "36d29258901a4d8c296baa68", "snowflake": "9e4a50a8aab648a9737f7d0c", @@ -12486,8 +12486,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -12497,16 +12497,16 @@ [ "type", { -"DuckDB": "8731ee5ed03816bf6b4a8464", +"DuckDB": "9c4e957c3856f1159283313a", "None": "8731ee5ed03816bf6b4a8464", "bigquery": "657a69dabb6a9b2c7b834d41", "databricks": "606d813c3f1dfcf4921045c8", -"duckdb": "8731ee5ed03816bf6b4a8464", +"duckdb": "9c4e957c3856f1159283313a", "generic": "8731ee5ed03816bf6b4a8464", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b9f1a78bcda3bc968346cc10", -"postgres": "8731ee5ed03816bf6b4a8464", -"postgresql": "8731ee5ed03816bf6b4a8464", +"motherduck": "9c4e957c3856f1159283313a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9c4e957c3856f1159283313a", +"postgresql": "9c4e957c3856f1159283313a", "snowflake": "cd2eb5ae8b54388fde5d5737", "tsql": "8619573249fac6f54d0bc771" } @@ -12520,8 +12520,8 @@ "databricks": "70fb4728c3adcf6dbe4975d5", "duckdb": "70fb4728c3adcf6dbe4975d5", "generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", @@ -12537,10 +12537,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -12554,8 +12554,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -12565,18 +12565,18 @@ [ "type", { -"DuckDB": "9ebaaf01ad47894d796ac621", -"None": "00caaa5ad0660c8df2165071", +"DuckDB": "0ceb777141e874f9277f0f53", +"None": "18cb3eafdbb91b315055426b", "bigquery": "18cb3eafdbb91b315055426b", -"databricks": "7321b96df327a001959868b6", -"duckdb": "9ebaaf01ad47894d796ac621", -"generic": "00caaa5ad0660c8df2165071", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "00caaa5ad0660c8df2165071", -"postgres": "00caaa5ad0660c8df2165071", -"postgresql": "00caaa5ad0660c8df2165071", +"databricks": "c77c5b64930f0a65094fd575", +"duckdb": "0ceb777141e874f9277f0f53", +"generic": "18cb3eafdbb91b315055426b", +"motherduck": "0ceb777141e874f9277f0f53", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "18cb3eafdbb91b315055426b", +"postgresql": "18cb3eafdbb91b315055426b", "snowflake": "d5bfcc48faca639b47d37309", -"tsql": "00caaa5ad0660c8df2165071" +"tsql": "18cb3eafdbb91b315055426b" } ], [ @@ -12588,8 +12588,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -12600,34 +12600,34 @@ "type", { "DuckDB": "7a79790250ede37cbc407ce6", -"None": "4425df9f96e51bc0984eab91", -"bigquery": "135a912ea74f76a35d9d0632", -"databricks": "4425df9f96e51bc0984eab91", +"None": "398f4aeaabc39054d76e214e", +"bigquery": "398f4aeaabc39054d76e214e", +"databricks": "398f4aeaabc39054d76e214e", "duckdb": "7a79790250ede37cbc407ce6", -"generic": "4425df9f96e51bc0984eab91", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "7a79790250ede37cbc407ce6", -"postgresql": "7a79790250ede37cbc407ce6", -"snowflake": "061ecb71b8d0a25345bb4dc5", -"tsql": "d1dc9a140dbe2eb1874c6ad7" +"generic": "398f4aeaabc39054d76e214e", +"motherduck": "7a79790250ede37cbc407ce6", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "398f4aeaabc39054d76e214e", +"postgresql": "398f4aeaabc39054d76e214e", +"snowflake": "398f4aeaabc39054d76e214e", +"tsql": "398f4aeaabc39054d76e214e" } ], [ "type", { "DuckDB": "c50a316d091c821866e4bfba", -"None": "c50a316d091c821866e4bfba", -"bigquery": "c50a316d091c821866e4bfba", -"databricks": "c50a316d091c821866e4bfba", +"None": "e6ffdece2977be55da73b59a", +"bigquery": "e6ffdece2977be55da73b59a", +"databricks": "e6ffdece2977be55da73b59a", "duckdb": "c50a316d091c821866e4bfba", -"generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"generic": "e6ffdece2977be55da73b59a", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", -"tsql": "c50a316d091c821866e4bfba" +"tsql": "e6ffdece2977be55da73b59a" } ], [ @@ -12639,10 +12639,10 @@ "databricks": "d227b99a82e505d599c2ed8a", "duckdb": "35a9c5c1419bff507cf65ae2", "generic": "d227b99a82e505d599c2ed8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d227b99a82e505d599c2ed8a", -"postgres": "d227b99a82e505d599c2ed8a", -"postgresql": "d227b99a82e505d599c2ed8a", +"motherduck": "35a9c5c1419bff507cf65ae2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "35a9c5c1419bff507cf65ae2", +"postgresql": "35a9c5c1419bff507cf65ae2", "snowflake": "d227b99a82e505d599c2ed8a", "tsql": "d227b99a82e505d599c2ed8a" } @@ -12652,12 +12652,12 @@ { "DuckDB": "4ed568ea1adb2c8a7141be20", "None": "b981394a3f4d961a44e73868", -"bigquery": "b981394a3f4d961a44e73868", +"bigquery": "135a912ea74f76a35d9d0632", "databricks": "b981394a3f4d961a44e73868", "duckdb": "4ed568ea1adb2c8a7141be20", "generic": "b981394a3f4d961a44e73868", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "4ed568ea1adb2c8a7141be20", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4ed568ea1adb2c8a7141be20", "postgresql": "4ed568ea1adb2c8a7141be20", "snowflake": "b63ef04215d2dd65ccf32905", @@ -12673,8 +12673,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -12690,8 +12690,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -12702,32 +12702,32 @@ "type", { "DuckDB": "f46cf4b4e131aa122b5b33d6", -"None": "f46cf4b4e131aa122b5b33d6", -"bigquery": "f46cf4b4e131aa122b5b33d6", -"databricks": "f46cf4b4e131aa122b5b33d6", +"None": "f774d5e8feadbf11edaa26b1", +"bigquery": "9bafb08d41fd1c208b5deca4", +"databricks": "f774d5e8feadbf11edaa26b1", "duckdb": "f46cf4b4e131aa122b5b33d6", -"generic": "f46cf4b4e131aa122b5b33d6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f46cf4b4e131aa122b5b33d6", +"generic": "f774d5e8feadbf11edaa26b1", +"motherduck": "f46cf4b4e131aa122b5b33d6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f46cf4b4e131aa122b5b33d6", "postgresql": "f46cf4b4e131aa122b5b33d6", "snowflake": "f46cf4b4e131aa122b5b33d6", -"tsql": "f46cf4b4e131aa122b5b33d6" +"tsql": "f774d5e8feadbf11edaa26b1" } ], [ "type", { -"DuckDB": "4172129e8d84a0da597bc612", +"DuckDB": "0da0fad3107f7a26744c9411", "None": "4172129e8d84a0da597bc612", "bigquery": "d138b3b3355094a33a14355a", "databricks": "4172129e8d84a0da597bc612", -"duckdb": "4172129e8d84a0da597bc612", +"duckdb": "0da0fad3107f7a26744c9411", "generic": "4172129e8d84a0da597bc612", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "4172129e8d84a0da597bc612", -"postgresql": "4172129e8d84a0da597bc612", +"motherduck": "0da0fad3107f7a26744c9411", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "0da0fad3107f7a26744c9411", +"postgresql": "0da0fad3107f7a26744c9411", "snowflake": "e21aafb74f6e5c5e181abd5e", "tsql": "2e261f2f5a01e0e0f4a34a7a" } @@ -12741,8 +12741,8 @@ "databricks": "5c528c7b4329aeb692ec6e94", "duckdb": "5c528c7b4329aeb692ec6e94", "generic": "5c528c7b4329aeb692ec6e94", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c528c7b4329aeb692ec6e94", +"motherduck": "5c528c7b4329aeb692ec6e94", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5c528c7b4329aeb692ec6e94", "postgresql": "5c528c7b4329aeb692ec6e94", "snowflake": "5c528c7b4329aeb692ec6e94", @@ -12758,8 +12758,8 @@ "databricks": "b66ef401bfc62ea5f67697f0", "duckdb": "b66ef401bfc62ea5f67697f0", "generic": "b66ef401bfc62ea5f67697f0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b66ef401bfc62ea5f67697f0", +"motherduck": "b66ef401bfc62ea5f67697f0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b66ef401bfc62ea5f67697f0", "postgresql": "b66ef401bfc62ea5f67697f0", "snowflake": "b66ef401bfc62ea5f67697f0", @@ -12769,18 +12769,18 @@ [ "type", { -"DuckDB": "67b955e24db58c73ccf37441", -"None": "7390a6531648a24d91197039", +"DuckDB": "8a72102ccfafa4befa09244b", +"None": "41beda08d4df864cb9dd8402", "bigquery": "41beda08d4df864cb9dd8402", "databricks": "41beda08d4df864cb9dd8402", -"duckdb": "67b955e24db58c73ccf37441", -"generic": "7390a6531648a24d91197039", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "41beda08d4df864cb9dd8402", -"postgres": "4d6c7e32aac20e9e4fb2369e", -"postgresql": "4d6c7e32aac20e9e4fb2369e", +"duckdb": "8a72102ccfafa4befa09244b", +"generic": "41beda08d4df864cb9dd8402", +"motherduck": "8a72102ccfafa4befa09244b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "41beda08d4df864cb9dd8402", +"postgresql": "41beda08d4df864cb9dd8402", "snowflake": "bae18d740565e7e0e416c8f3", -"tsql": "762b596d819e7050cff38fb8" +"tsql": "41beda08d4df864cb9dd8402" } ], [ @@ -12788,14 +12788,14 @@ { "DuckDB": "c4346d0257336219f1d26890", "None": "c4346d0257336219f1d26890", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "c4346d0257336219f1d26890", "duckdb": "c4346d0257336219f1d26890", "generic": "c4346d0257336219f1d26890", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c4346d0257336219f1d26890", -"postgres": "c4346d0257336219f1d26890", -"postgresql": "c4346d0257336219f1d26890", +"motherduck": "c4346d0257336219f1d26890", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "19bdd92ea0cc5fb028657510", +"postgresql": "19bdd92ea0cc5fb028657510", "snowflake": "4e24a80b20b9dee0cbbfac17", "tsql": "c4346d0257336219f1d26890" } @@ -12809,8 +12809,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -12826,8 +12826,8 @@ "databricks": "b137c998bdaa2555d912e8fa", "duckdb": "27f973a6b2da27a79f5c0074", "generic": "b137c998bdaa2555d912e8fa", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b137c998bdaa2555d912e8fa", +"motherduck": "27f973a6b2da27a79f5c0074", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b137c998bdaa2555d912e8fa", "postgresql": "b137c998bdaa2555d912e8fa", "snowflake": "b137c998bdaa2555d912e8fa", @@ -12843,8 +12843,8 @@ "databricks": "ab5ad6180652b3b00d1f5b01", "duckdb": "ab5ad6180652b3b00d1f5b01", "generic": "ab5ad6180652b3b00d1f5b01", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ab5ad6180652b3b00d1f5b01", +"motherduck": "ab5ad6180652b3b00d1f5b01", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ab5ad6180652b3b00d1f5b01", "postgresql": "ab5ad6180652b3b00d1f5b01", "snowflake": "f43dac38f34a1c0618a3f812", @@ -12860,10 +12860,10 @@ "databricks": "336fd1b7a1f7d8105c29280c", "duckdb": "0baaca265927140414f32b37", "generic": "336fd1b7a1f7d8105c29280c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "336fd1b7a1f7d8105c29280c", -"postgres": "336fd1b7a1f7d8105c29280c", -"postgresql": "336fd1b7a1f7d8105c29280c", +"motherduck": "0baaca265927140414f32b37", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9ea4932505663b43f527adad", +"postgresql": "9ea4932505663b43f527adad", "snowflake": "336fd1b7a1f7d8105c29280c", "tsql": "336fd1b7a1f7d8105c29280c" } @@ -12877,10 +12877,10 @@ "databricks": "0960c90223e1eca15361360f", "duckdb": "0960c90223e1eca15361360f", "generic": "0960c90223e1eca15361360f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0960c90223e1eca15361360f", -"postgres": "0960c90223e1eca15361360f", -"postgresql": "0960c90223e1eca15361360f", +"motherduck": "0960c90223e1eca15361360f", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "b72367ce0764c938c620a44c", +"postgresql": "b72367ce0764c938c620a44c", "snowflake": "0960c90223e1eca15361360f", "tsql": "0960c90223e1eca15361360f" } @@ -12894,8 +12894,8 @@ "databricks": "b46dfa976d5ba04f95bea32b", "duckdb": "b46dfa976d5ba04f95bea32b", "generic": "b46dfa976d5ba04f95bea32b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b46dfa976d5ba04f95bea32b", +"motherduck": "b46dfa976d5ba04f95bea32b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "34dcdfe3e3afe6140e1353e0", "postgresql": "34dcdfe3e3afe6140e1353e0", "snowflake": "b46dfa976d5ba04f95bea32b", @@ -12911,8 +12911,8 @@ "databricks": "b66ef401bfc62ea5f67697f0", "duckdb": "b66ef401bfc62ea5f67697f0", "generic": "b66ef401bfc62ea5f67697f0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b66ef401bfc62ea5f67697f0", +"motherduck": "b66ef401bfc62ea5f67697f0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b66ef401bfc62ea5f67697f0", "postgresql": "b66ef401bfc62ea5f67697f0", "snowflake": "b66ef401bfc62ea5f67697f0", @@ -12924,14 +12924,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -12945,8 +12945,8 @@ "databricks": "d90a78129f7050a540984f6f", "duckdb": "66f7ca02161349d637fa7d4e", "generic": "66f7ca02161349d637fa7d4e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d90a78129f7050a540984f6f", +"motherduck": "66f7ca02161349d637fa7d4e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "66f7ca02161349d637fa7d4e", "postgresql": "66f7ca02161349d637fa7d4e", "snowflake": "66f7ca02161349d637fa7d4e", @@ -12956,18 +12956,18 @@ [ "type", { -"DuckDB": "6b7315cdb8da9cc8682fe582", -"None": "5db36cde08c21101926533c6", -"bigquery": "be1298bd832c06e2fbed16cc", -"databricks": "68c9a65b028d0f4e1e431d2b", -"duckdb": "6b7315cdb8da9cc8682fe582", -"generic": "5db36cde08c21101926533c6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3a28322a1d9fe5f73ddf21a6", -"postgres": "627a2125b73642795b93f3ec", -"postgresql": "627a2125b73642795b93f3ec", +"DuckDB": "20949d5f5c24adb922f1df86", +"None": "8c977bea8b7e2befaacba9a7", +"bigquery": "8c977bea8b7e2befaacba9a7", +"databricks": "8c977bea8b7e2befaacba9a7", +"duckdb": "20949d5f5c24adb922f1df86", +"generic": "8c977bea8b7e2befaacba9a7", +"motherduck": "20949d5f5c24adb922f1df86", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8c977bea8b7e2befaacba9a7", +"postgresql": "8c977bea8b7e2befaacba9a7", "snowflake": "c990ce1e11ec35da455f1547", -"tsql": "5db36cde08c21101926533c6" +"tsql": "8c977bea8b7e2befaacba9a7" } ], [ @@ -12979,10 +12979,10 @@ "databricks": "26e466cea9d3c66c226e9bbb", "duckdb": "26e466cea9d3c66c226e9bbb", "generic": "26e466cea9d3c66c226e9bbb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "26e466cea9d3c66c226e9bbb", -"postgres": "26e466cea9d3c66c226e9bbb", -"postgresql": "26e466cea9d3c66c226e9bbb", +"motherduck": "26e466cea9d3c66c226e9bbb", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a1fa261c560b019889bf4835", +"postgresql": "a1fa261c560b019889bf4835", "snowflake": "26e466cea9d3c66c226e9bbb", "tsql": "26e466cea9d3c66c226e9bbb" } @@ -12991,34 +12991,34 @@ "type", { "DuckDB": "31efc7b307bffec917380e8e", -"None": "31efc7b307bffec917380e8e", -"bigquery": "31efc7b307bffec917380e8e", -"databricks": "31efc7b307bffec917380e8e", +"None": "ed874ecba919fbd97b7f6780", +"bigquery": "ed874ecba919fbd97b7f6780", +"databricks": "ed874ecba919fbd97b7f6780", "duckdb": "31efc7b307bffec917380e8e", -"generic": "31efc7b307bffec917380e8e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "31efc7b307bffec917380e8e", +"generic": "ed874ecba919fbd97b7f6780", +"motherduck": "31efc7b307bffec917380e8e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "31efc7b307bffec917380e8e", "postgresql": "31efc7b307bffec917380e8e", "snowflake": "42d4a23d9a52e79d0c3458d3", -"tsql": "31efc7b307bffec917380e8e" +"tsql": "ed874ecba919fbd97b7f6780" } ], [ "type", { "DuckDB": "2f9ac8bd6831b78665301f10", -"None": "2f9ac8bd6831b78665301f10", -"bigquery": "2f9ac8bd6831b78665301f10", -"databricks": "2f9ac8bd6831b78665301f10", +"None": "c557f7ce51bc180332354184", +"bigquery": "09b7f1f9111bc2e0767cc059", +"databricks": "c557f7ce51bc180332354184", "duckdb": "2f9ac8bd6831b78665301f10", -"generic": "2f9ac8bd6831b78665301f10", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2f9ac8bd6831b78665301f10", +"generic": "c557f7ce51bc180332354184", +"motherduck": "2f9ac8bd6831b78665301f10", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2f9ac8bd6831b78665301f10", "postgresql": "2f9ac8bd6831b78665301f10", "snowflake": "2f9ac8bd6831b78665301f10", -"tsql": "2f9ac8bd6831b78665301f10" +"tsql": "c557f7ce51bc180332354184" } ], [ @@ -13030,8 +13030,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -13047,8 +13047,8 @@ "databricks": "7102b9514dfef58f8673a6bf", "duckdb": "7102b9514dfef58f8673a6bf", "generic": "7102b9514dfef58f8673a6bf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7102b9514dfef58f8673a6bf", +"motherduck": "7102b9514dfef58f8673a6bf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7102b9514dfef58f8673a6bf", "postgresql": "7102b9514dfef58f8673a6bf", "snowflake": "7102b9514dfef58f8673a6bf", @@ -13064,8 +13064,8 @@ "databricks": "6d7ab232e65fe8d85c7169ae", "duckdb": "6d7ab232e65fe8d85c7169ae", "generic": "6d7ab232e65fe8d85c7169ae", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6d7ab232e65fe8d85c7169ae", +"motherduck": "6d7ab232e65fe8d85c7169ae", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a6659d96bbfa5da75e69e22d", "postgresql": "a6659d96bbfa5da75e69e22d", "snowflake": "6d7ab232e65fe8d85c7169ae", @@ -13081,8 +13081,8 @@ "databricks": "e7683084f9cefaf3748cf526", "duckdb": "e7683084f9cefaf3748cf526", "generic": "e7683084f9cefaf3748cf526", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e7683084f9cefaf3748cf526", +"motherduck": "e7683084f9cefaf3748cf526", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e7683084f9cefaf3748cf526", "postgresql": "e7683084f9cefaf3748cf526", "snowflake": "e7683084f9cefaf3748cf526", @@ -13098,8 +13098,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -13115,8 +13115,8 @@ "databricks": "50a940812c6ed2e6dd842e74", "duckdb": "50a940812c6ed2e6dd842e74", "generic": "50a940812c6ed2e6dd842e74", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "50a940812c6ed2e6dd842e74", +"motherduck": "50a940812c6ed2e6dd842e74", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "50a940812c6ed2e6dd842e74", "postgresql": "50a940812c6ed2e6dd842e74", "snowflake": "50a940812c6ed2e6dd842e74", @@ -13132,8 +13132,8 @@ "databricks": "e1c74d96ac578f9323bf1bbd", "duckdb": "e1c74d96ac578f9323bf1bbd", "generic": "e1c74d96ac578f9323bf1bbd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e1c74d96ac578f9323bf1bbd", +"motherduck": "e1c74d96ac578f9323bf1bbd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e1c74d96ac578f9323bf1bbd", "postgresql": "e1c74d96ac578f9323bf1bbd", "snowflake": "e1c74d96ac578f9323bf1bbd", @@ -13149,8 +13149,8 @@ "databricks": "d6e37cd37419bfb26e09b080", "duckdb": "d6e37cd37419bfb26e09b080", "generic": "d6e37cd37419bfb26e09b080", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d6e37cd37419bfb26e09b080", +"motherduck": "d6e37cd37419bfb26e09b080", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d6e37cd37419bfb26e09b080", "postgresql": "d6e37cd37419bfb26e09b080", "snowflake": "d6e37cd37419bfb26e09b080", @@ -13166,10 +13166,10 @@ "databricks": "de89632e277dbc8c97115419", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -13178,16 +13178,16 @@ "type", { "DuckDB": "7a79790250ede37cbc407ce6", -"None": "4425df9f96e51bc0984eab91", -"bigquery": "135a912ea74f76a35d9d0632", -"databricks": "4425df9f96e51bc0984eab91", +"None": "45809055304b61252670382f", +"bigquery": "45809055304b61252670382f", +"databricks": "45809055304b61252670382f", "duckdb": "7a79790250ede37cbc407ce6", -"generic": "4425df9f96e51bc0984eab91", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "7a79790250ede37cbc407ce6", -"postgresql": "7a79790250ede37cbc407ce6", -"snowflake": "061ecb71b8d0a25345bb4dc5", +"generic": "45809055304b61252670382f", +"motherduck": "7a79790250ede37cbc407ce6", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "45809055304b61252670382f", +"postgresql": "45809055304b61252670382f", +"snowflake": "45809055304b61252670382f", "tsql": "45809055304b61252670382f" } ], @@ -13200,8 +13200,8 @@ "databricks": "dcb00b7053ffe69fe3ce99cd", "duckdb": "c7b697bbfa82dd2821ad64e9", "generic": "c7b697bbfa82dd2821ad64e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "dcb00b7053ffe69fe3ce99cd", +"motherduck": "c7b697bbfa82dd2821ad64e9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c7b697bbfa82dd2821ad64e9", "postgresql": "c7b697bbfa82dd2821ad64e9", "snowflake": "c7b697bbfa82dd2821ad64e9", @@ -13217,8 +13217,8 @@ "databricks": "66acfa34471e60551c71ca8a", "duckdb": "66acfa34471e60551c71ca8a", "generic": "66acfa34471e60551c71ca8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "66acfa34471e60551c71ca8a", +"motherduck": "66acfa34471e60551c71ca8a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "66acfa34471e60551c71ca8a", "postgresql": "66acfa34471e60551c71ca8a", "snowflake": "6306b9e88f7b13dbb6a32c00", @@ -13234,8 +13234,8 @@ "databricks": "bca4e355ae48af6503cb15b3", "duckdb": "793afe64018cd40f2abf8cd7", "generic": "793afe64018cd40f2abf8cd7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "793afe64018cd40f2abf8cd7", +"motherduck": "793afe64018cd40f2abf8cd7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "793afe64018cd40f2abf8cd7", "postgresql": "793afe64018cd40f2abf8cd7", "snowflake": "c0351067a884fbee21c680b3", @@ -13251,8 +13251,8 @@ "databricks": "0c40d2d16c130d68a7c6c41d", "duckdb": "0c40d2d16c130d68a7c6c41d", "generic": "0c40d2d16c130d68a7c6c41d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0c40d2d16c130d68a7c6c41d", +"motherduck": "0c40d2d16c130d68a7c6c41d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0c40d2d16c130d68a7c6c41d", "postgresql": "0c40d2d16c130d68a7c6c41d", "snowflake": "0c40d2d16c130d68a7c6c41d", @@ -13268,10 +13268,10 @@ "databricks": "18db5afe2c1e80d1ee652b54", "duckdb": "18db5afe2c1e80d1ee652b54", "generic": "18db5afe2c1e80d1ee652b54", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "18db5afe2c1e80d1ee652b54", -"postgres": "18db5afe2c1e80d1ee652b54", -"postgresql": "18db5afe2c1e80d1ee652b54", +"motherduck": "18db5afe2c1e80d1ee652b54", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "47d64a5994d42a2b577166ea", +"postgresql": "47d64a5994d42a2b577166ea", "snowflake": "18db5afe2c1e80d1ee652b54", "tsql": "18db5afe2c1e80d1ee652b54" } @@ -13285,8 +13285,8 @@ "databricks": "f73576af0cd50cbe498a0092", "duckdb": "f73576af0cd50cbe498a0092", "generic": "f73576af0cd50cbe498a0092", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f73576af0cd50cbe498a0092", +"motherduck": "f73576af0cd50cbe498a0092", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f73576af0cd50cbe498a0092", "postgresql": "f73576af0cd50cbe498a0092", "snowflake": "f73576af0cd50cbe498a0092", @@ -13302,8 +13302,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -13319,8 +13319,8 @@ "databricks": "83fdbd1f0a6ee4e72faa4d94", "duckdb": "83fdbd1f0a6ee4e72faa4d94", "generic": "83fdbd1f0a6ee4e72faa4d94", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "83fdbd1f0a6ee4e72faa4d94", +"motherduck": "83fdbd1f0a6ee4e72faa4d94", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "83fdbd1f0a6ee4e72faa4d94", "postgresql": "83fdbd1f0a6ee4e72faa4d94", "snowflake": "83fdbd1f0a6ee4e72faa4d94", @@ -13336,8 +13336,8 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "355e032cc5c0f24695836b3d", "generic": "355e032cc5c0f24695836b3d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "355e032cc5c0f24695836b3d", +"motherduck": "355e032cc5c0f24695836b3d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b0b09c4a6f7570ece56f59ce", "postgresql": "b0b09c4a6f7570ece56f59ce", "snowflake": "355e032cc5c0f24695836b3d", @@ -13353,8 +13353,8 @@ "databricks": "a40042061a75dff39acf27ea", "duckdb": "a40042061a75dff39acf27ea", "generic": "a40042061a75dff39acf27ea", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a40042061a75dff39acf27ea", +"motherduck": "a40042061a75dff39acf27ea", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a40042061a75dff39acf27ea", "postgresql": "a40042061a75dff39acf27ea", "snowflake": "a40042061a75dff39acf27ea", @@ -13366,14 +13366,14 @@ { "DuckDB": "e46d4be44ab9e500e9190d26", "None": "e46d4be44ab9e500e9190d26", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -13383,12 +13383,12 @@ { "DuckDB": "d0c95c7a10940244afe0eb6c", "None": "d0c95c7a10940244afe0eb6c", -"bigquery": "23ee196b7bd6039855a1460f", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "d0c95c7a10940244afe0eb6c", "duckdb": "d0c95c7a10940244afe0eb6c", "generic": "d0c95c7a10940244afe0eb6c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d0c95c7a10940244afe0eb6c", +"motherduck": "d0c95c7a10940244afe0eb6c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d0c95c7a10940244afe0eb6c", "postgresql": "d0c95c7a10940244afe0eb6c", "snowflake": "d0c95c7a10940244afe0eb6c", @@ -13400,12 +13400,12 @@ { "DuckDB": "5c28019dce48a74708c90a76", "None": "5c28019dce48a74708c90a76", -"bigquery": "f28a96f0eb38ad8874f6ec5d", +"bigquery": "5c28019dce48a74708c90a76", "databricks": "5c28019dce48a74708c90a76", "duckdb": "5c28019dce48a74708c90a76", "generic": "5c28019dce48a74708c90a76", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "5c28019dce48a74708c90a76", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5c28019dce48a74708c90a76", "postgresql": "5c28019dce48a74708c90a76", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -13421,8 +13421,8 @@ "databricks": "2e4ac90e0dc84f220169a428", "duckdb": "2e4ac90e0dc84f220169a428", "generic": "2e4ac90e0dc84f220169a428", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2e4ac90e0dc84f220169a428", +"motherduck": "2e4ac90e0dc84f220169a428", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2e4ac90e0dc84f220169a428", "postgresql": "2e4ac90e0dc84f220169a428", "snowflake": "2e4ac90e0dc84f220169a428", @@ -13438,8 +13438,8 @@ "databricks": "f94b458b28b4e92e314740bf", "duckdb": "f94b458b28b4e92e314740bf", "generic": "f94b458b28b4e92e314740bf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f94b458b28b4e92e314740bf", +"motherduck": "f94b458b28b4e92e314740bf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f94b458b28b4e92e314740bf", "postgresql": "f94b458b28b4e92e314740bf", "snowflake": "f94b458b28b4e92e314740bf", @@ -13455,10 +13455,10 @@ "databricks": "2705f19942a4194a72576911", "duckdb": "2705f19942a4194a72576911", "generic": "2705f19942a4194a72576911", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2705f19942a4194a72576911", -"postgres": "2705f19942a4194a72576911", -"postgresql": "2705f19942a4194a72576911", +"motherduck": "2705f19942a4194a72576911", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5226d7e2a62c7650a87d6e84", +"postgresql": "5226d7e2a62c7650a87d6e84", "snowflake": "2705f19942a4194a72576911", "tsql": "2705f19942a4194a72576911" } @@ -13472,8 +13472,8 @@ "databricks": "42a76d5ff05d0f91911ff368", "duckdb": "42a76d5ff05d0f91911ff368", "generic": "42a76d5ff05d0f91911ff368", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "42a76d5ff05d0f91911ff368", +"motherduck": "42a76d5ff05d0f91911ff368", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "42a76d5ff05d0f91911ff368", "postgresql": "42a76d5ff05d0f91911ff368", "snowflake": "42a76d5ff05d0f91911ff368", @@ -13485,14 +13485,14 @@ { "DuckDB": "de89632e277dbc8c97115419", "None": "de89632e277dbc8c97115419", -"bigquery": "de89632e277dbc8c97115419", +"bigquery": "5abf4ec799a2ec32fb10da7e", "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -13506,8 +13506,8 @@ "databricks": "f94b458b28b4e92e314740bf", "duckdb": "f94b458b28b4e92e314740bf", "generic": "f94b458b28b4e92e314740bf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f94b458b28b4e92e314740bf", +"motherduck": "f94b458b28b4e92e314740bf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f94b458b28b4e92e314740bf", "postgresql": "f94b458b28b4e92e314740bf", "snowflake": "f94b458b28b4e92e314740bf", @@ -13523,10 +13523,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -13540,8 +13540,8 @@ "databricks": "7c11e0be7630905d93bd9ce1", "duckdb": "7c11e0be7630905d93bd9ce1", "generic": "7c11e0be7630905d93bd9ce1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7c11e0be7630905d93bd9ce1", +"motherduck": "7c11e0be7630905d93bd9ce1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7c11e0be7630905d93bd9ce1", "postgresql": "7c11e0be7630905d93bd9ce1", "snowflake": "7c11e0be7630905d93bd9ce1", @@ -13557,8 +13557,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -13570,14 +13570,14 @@ { "DuckDB": "181c436b3522e70edf3adf58", "None": "181c436b3522e70edf3adf58", -"bigquery": "181c436b3522e70edf3adf58", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "181c436b3522e70edf3adf58", "duckdb": "181c436b3522e70edf3adf58", "generic": "181c436b3522e70edf3adf58", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "181c436b3522e70edf3adf58", -"postgres": "181c436b3522e70edf3adf58", -"postgresql": "181c436b3522e70edf3adf58", +"motherduck": "181c436b3522e70edf3adf58", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "7560dc4d0678d613b6142654", +"postgresql": "7560dc4d0678d613b6142654", "snowflake": "181c436b3522e70edf3adf58", "tsql": "181c436b3522e70edf3adf58" } @@ -13585,18 +13585,18 @@ [ "type", { -"DuckDB": "24c3d9dcce7ee2c5b2bac1df", -"None": "547c73a68a3263d4ca786f4d", -"bigquery": "547c73a68a3263d4ca786f4d", -"databricks": "3ad35a92f1fdd0560316b488", -"duckdb": "24c3d9dcce7ee2c5b2bac1df", -"generic": "547c73a68a3263d4ca786f4d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "24c3d9dcce7ee2c5b2bac1df", -"postgresql": "24c3d9dcce7ee2c5b2bac1df", -"snowflake": "0591bc1bf9f4f62b80103d53", -"tsql": "d1dc9a140dbe2eb1874c6ad7" +"DuckDB": "2bd744f24899a7b211c526d9", +"None": "2bd744f24899a7b211c526d9", +"bigquery": "2bd744f24899a7b211c526d9", +"databricks": "2bd744f24899a7b211c526d9", +"duckdb": "2bd744f24899a7b211c526d9", +"generic": "2bd744f24899a7b211c526d9", +"motherduck": "2bd744f24899a7b211c526d9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2bd744f24899a7b211c526d9", +"postgresql": "2bd744f24899a7b211c526d9", +"snowflake": "2bd744f24899a7b211c526d9", +"tsql": "2bd744f24899a7b211c526d9" } ], [ @@ -13608,8 +13608,8 @@ "databricks": "b60a7259ca26ea325ba090a1", "duckdb": "b60a7259ca26ea325ba090a1", "generic": "b60a7259ca26ea325ba090a1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b60a7259ca26ea325ba090a1", +"motherduck": "b60a7259ca26ea325ba090a1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b60a7259ca26ea325ba090a1", "postgresql": "b60a7259ca26ea325ba090a1", "snowflake": "b60a7259ca26ea325ba090a1", @@ -13625,8 +13625,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -13636,14 +13636,14 @@ [ "type", { -"DuckDB": "285056becb5d467811be7cd6", +"DuckDB": "0712c33a016f7dd6a37ee011", "None": "285056becb5d467811be7cd6", "bigquery": "0712c33a016f7dd6a37ee011", "databricks": "285056becb5d467811be7cd6", -"duckdb": "285056becb5d467811be7cd6", +"duckdb": "0712c33a016f7dd6a37ee011", "generic": "285056becb5d467811be7cd6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fc10fc558d906a80a6404b7f", +"motherduck": "0712c33a016f7dd6a37ee011", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "285056becb5d467811be7cd6", "postgresql": "285056becb5d467811be7cd6", "snowflake": "0712c33a016f7dd6a37ee011", @@ -13655,14 +13655,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -13672,14 +13672,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -13688,17 +13688,17 @@ "type", { "DuckDB": "a3b6b25265be330ec52a3322", -"None": "a3b6b25265be330ec52a3322", -"bigquery": "204206d1d1eecf007966cc5b", -"databricks": "e3bc1b8bad22d8104417b00f", +"None": "62368fc15cefd5807807b209", +"bigquery": "c50a316d091c821866e4bfba", +"databricks": "62368fc15cefd5807807b209", "duckdb": "a3b6b25265be330ec52a3322", -"generic": "a3b6b25265be330ec52a3322", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "919b7ec6a7b49d8527b784cd", -"postgres": "a3b6b25265be330ec52a3322", -"postgresql": "a3b6b25265be330ec52a3322", +"generic": "62368fc15cefd5807807b209", +"motherduck": "a3b6b25265be330ec52a3322", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "62368fc15cefd5807807b209", +"postgresql": "62368fc15cefd5807807b209", "snowflake": "919b7ec6a7b49d8527b784cd", -"tsql": "a3b6b25265be330ec52a3322" +"tsql": "62368fc15cefd5807807b209" } ], [ @@ -13706,14 +13706,14 @@ { "DuckDB": "4d0f0db1a550ed1e0da1a043", "None": "4d0f0db1a550ed1e0da1a043", -"bigquery": "4d0f0db1a550ed1e0da1a043", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "4d0f0db1a550ed1e0da1a043", "duckdb": "4d0f0db1a550ed1e0da1a043", "generic": "4d0f0db1a550ed1e0da1a043", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4d0f0db1a550ed1e0da1a043", -"postgres": "4d0f0db1a550ed1e0da1a043", -"postgresql": "4d0f0db1a550ed1e0da1a043", +"motherduck": "4d0f0db1a550ed1e0da1a043", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e47320d1030c166a05193bc4", +"postgresql": "e47320d1030c166a05193bc4", "snowflake": "4d0f0db1a550ed1e0da1a043", "tsql": "4d0f0db1a550ed1e0da1a043" } @@ -13722,17 +13722,17 @@ "type", { "DuckDB": "6f4372a332076048e56d5076", -"None": "6f4372a332076048e56d5076", -"bigquery": "74a30f6aa9def0b58afc616c", -"databricks": "6f4372a332076048e56d5076", +"None": "fa78cfa46a78783d069e2fc5", +"bigquery": "b0477b36767a62145aa9158c", +"databricks": "fa78cfa46a78783d069e2fc5", "duckdb": "6f4372a332076048e56d5076", -"generic": "6f4372a332076048e56d5076", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6f4372a332076048e56d5076", +"generic": "fa78cfa46a78783d069e2fc5", +"motherduck": "6f4372a332076048e56d5076", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6f4372a332076048e56d5076", "postgresql": "6f4372a332076048e56d5076", "snowflake": "daeeb0f00b3ee4211b8da00f", -"tsql": "6f4372a332076048e56d5076" +"tsql": "fa78cfa46a78783d069e2fc5" } ], [ @@ -13740,12 +13740,12 @@ { "DuckDB": "62368fc15cefd5807807b209", "None": "62368fc15cefd5807807b209", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "62368fc15cefd5807807b209", "duckdb": "62368fc15cefd5807807b209", "generic": "62368fc15cefd5807807b209", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "62368fc15cefd5807807b209", +"motherduck": "62368fc15cefd5807807b209", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "62368fc15cefd5807807b209", "postgresql": "62368fc15cefd5807807b209", "snowflake": "62368fc15cefd5807807b209", @@ -13761,8 +13761,8 @@ "databricks": "e8b6e0bd2ded7b9eec6209e4", "duckdb": "e8b6e0bd2ded7b9eec6209e4", "generic": "e8b6e0bd2ded7b9eec6209e4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e8b6e0bd2ded7b9eec6209e4", +"motherduck": "e8b6e0bd2ded7b9eec6209e4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8b6e0bd2ded7b9eec6209e4", "postgresql": "e8b6e0bd2ded7b9eec6209e4", "snowflake": "e8b6e0bd2ded7b9eec6209e4", @@ -13773,17 +13773,17 @@ "type", { "DuckDB": "087a9417cb511ff7bcfd6ccb", -"None": "383f8922f4b6f167d384037d", -"bigquery": "383f8922f4b6f167d384037d", -"databricks": "383f8922f4b6f167d384037d", +"None": "2e8f6dfec4597fb9373329e7", +"bigquery": "2e8f6dfec4597fb9373329e7", +"databricks": "2e8f6dfec4597fb9373329e7", "duckdb": "087a9417cb511ff7bcfd6ccb", -"generic": "383f8922f4b6f167d384037d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "383f8922f4b6f167d384037d", +"generic": "2e8f6dfec4597fb9373329e7", +"motherduck": "087a9417cb511ff7bcfd6ccb", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "383f8922f4b6f167d384037d", "postgresql": "383f8922f4b6f167d384037d", "snowflake": "383f8922f4b6f167d384037d", -"tsql": "383f8922f4b6f167d384037d" +"tsql": "2e8f6dfec4597fb9373329e7" } ], [ @@ -13791,12 +13791,12 @@ { "DuckDB": "e08a957777bd278f921ca0ee", "None": "e08a957777bd278f921ca0ee", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "e08a957777bd278f921ca0ee", "duckdb": "e08a957777bd278f921ca0ee", "generic": "e08a957777bd278f921ca0ee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e08a957777bd278f921ca0ee", +"motherduck": "e08a957777bd278f921ca0ee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e08a957777bd278f921ca0ee", "postgresql": "e08a957777bd278f921ca0ee", "snowflake": "e08a957777bd278f921ca0ee", @@ -13812,8 +13812,8 @@ "databricks": "d79c3ac70093cb4cb531e71c", "duckdb": "d79c3ac70093cb4cb531e71c", "generic": "d79c3ac70093cb4cb531e71c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d79c3ac70093cb4cb531e71c", +"motherduck": "d79c3ac70093cb4cb531e71c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d79c3ac70093cb4cb531e71c", "postgresql": "d79c3ac70093cb4cb531e71c", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -13829,8 +13829,8 @@ "databricks": "688179272da645629077e980", "duckdb": "688179272da645629077e980", "generic": "688179272da645629077e980", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "688179272da645629077e980", +"motherduck": "688179272da645629077e980", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "688179272da645629077e980", "postgresql": "688179272da645629077e980", "snowflake": "b210f8eb26c37b422f786c6b", @@ -13842,12 +13842,12 @@ { "DuckDB": "e08a957777bd278f921ca0ee", "None": "e08a957777bd278f921ca0ee", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "e08a957777bd278f921ca0ee", "duckdb": "e08a957777bd278f921ca0ee", "generic": "e08a957777bd278f921ca0ee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e08a957777bd278f921ca0ee", +"motherduck": "e08a957777bd278f921ca0ee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e08a957777bd278f921ca0ee", "postgresql": "e08a957777bd278f921ca0ee", "snowflake": "e08a957777bd278f921ca0ee", @@ -13860,11 +13860,11 @@ "DuckDB": "3533f91995bca270f191503d", "None": "3533f91995bca270f191503d", "bigquery": "3533f91995bca270f191503d", -"databricks": "fcfd1f4cfe959c3d88cf43c4", +"databricks": "3533f91995bca270f191503d", "duckdb": "3533f91995bca270f191503d", "generic": "3533f91995bca270f191503d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "3533f91995bca270f191503d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3533f91995bca270f191503d", "postgresql": "3533f91995bca270f191503d", "snowflake": "3533f91995bca270f191503d", @@ -13880,8 +13880,8 @@ "databricks": "c2700ca3573352821e09af03", "duckdb": "c2700ca3573352821e09af03", "generic": "c2700ca3573352821e09af03", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c2700ca3573352821e09af03", +"motherduck": "c2700ca3573352821e09af03", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c2700ca3573352821e09af03", "postgresql": "c2700ca3573352821e09af03", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -13897,10 +13897,10 @@ "databricks": "eea9a25a6fbf8e049a445513", "duckdb": "eea9a25a6fbf8e049a445513", "generic": "eea9a25a6fbf8e049a445513", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "eea9a25a6fbf8e049a445513", -"postgres": "eea9a25a6fbf8e049a445513", -"postgresql": "eea9a25a6fbf8e049a445513", +"motherduck": "eea9a25a6fbf8e049a445513", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "769f762f4c7cffb2990ddacb", +"postgresql": "769f762f4c7cffb2990ddacb", "snowflake": "eea9a25a6fbf8e049a445513", "tsql": "eea9a25a6fbf8e049a445513" } @@ -13914,8 +13914,8 @@ "databricks": "251aba3fef503ce64556c701", "duckdb": "251aba3fef503ce64556c701", "generic": "251aba3fef503ce64556c701", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "251aba3fef503ce64556c701", +"motherduck": "251aba3fef503ce64556c701", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b7d6fc051a3c1ea6deb29ff4", "postgresql": "b7d6fc051a3c1ea6deb29ff4", "snowflake": "251aba3fef503ce64556c701", @@ -13931,8 +13931,8 @@ "databricks": "1a804f317a3e9a0016925b04", "duckdb": "110327dc45eac0e8d54a96dc", "generic": "110327dc45eac0e8d54a96dc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1a804f317a3e9a0016925b04", +"motherduck": "110327dc45eac0e8d54a96dc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "110327dc45eac0e8d54a96dc", "postgresql": "110327dc45eac0e8d54a96dc", "snowflake": "110327dc45eac0e8d54a96dc", @@ -13948,8 +13948,8 @@ "databricks": "d6e37cd37419bfb26e09b080", "duckdb": "d6e37cd37419bfb26e09b080", "generic": "d6e37cd37419bfb26e09b080", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d6e37cd37419bfb26e09b080", +"motherduck": "d6e37cd37419bfb26e09b080", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d6e37cd37419bfb26e09b080", "postgresql": "d6e37cd37419bfb26e09b080", "snowflake": "d6e37cd37419bfb26e09b080", @@ -13961,14 +13961,14 @@ { "DuckDB": "e46d4be44ab9e500e9190d26", "None": "e46d4be44ab9e500e9190d26", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -13982,8 +13982,8 @@ "databricks": "0703bf71a54942bdaa28406e", "duckdb": "0703bf71a54942bdaa28406e", "generic": "0703bf71a54942bdaa28406e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0703bf71a54942bdaa28406e", +"motherduck": "0703bf71a54942bdaa28406e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0703bf71a54942bdaa28406e", "postgresql": "0703bf71a54942bdaa28406e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -13999,8 +13999,8 @@ "databricks": "319a9fbb02ed503eb114164b", "duckdb": "e060b5a5a8e9774b580d58d3", "generic": "e060b5a5a8e9774b580d58d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "319a9fbb02ed503eb114164b", +"motherduck": "e060b5a5a8e9774b580d58d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e060b5a5a8e9774b580d58d3", "postgresql": "e060b5a5a8e9774b580d58d3", "snowflake": "e060b5a5a8e9774b580d58d3", @@ -14010,14 +14010,14 @@ [ "type", { -"DuckDB": "c6654395c62d21b415299f72", +"DuckDB": "0712c33a016f7dd6a37ee011", "None": "c6654395c62d21b415299f72", "bigquery": "0712c33a016f7dd6a37ee011", "databricks": "c6654395c62d21b415299f72", -"duckdb": "c6654395c62d21b415299f72", +"duckdb": "0712c33a016f7dd6a37ee011", "generic": "c6654395c62d21b415299f72", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2978a8fe925c7f93c6e9fcfb", +"motherduck": "0712c33a016f7dd6a37ee011", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6654395c62d21b415299f72", "postgresql": "c6654395c62d21b415299f72", "snowflake": "0712c33a016f7dd6a37ee011", @@ -14028,17 +14028,17 @@ "type", { "DuckDB": "b0fba0f56f0cfe71621226b5", -"None": "b0fba0f56f0cfe71621226b5", -"bigquery": "f7fffd42e662ab4655dceb3b", -"databricks": "94b22f27d5086eaa9bb3eff5", +"None": "71ad5cceb4fd8e86446cf461", +"bigquery": "71ad5cceb4fd8e86446cf461", +"databricks": "71ad5cceb4fd8e86446cf461", "duckdb": "b0fba0f56f0cfe71621226b5", -"generic": "b0fba0f56f0cfe71621226b5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b0fba0f56f0cfe71621226b5", -"postgres": "b0fba0f56f0cfe71621226b5", -"postgresql": "b0fba0f56f0cfe71621226b5", +"generic": "71ad5cceb4fd8e86446cf461", +"motherduck": "b0fba0f56f0cfe71621226b5", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "71ad5cceb4fd8e86446cf461", +"postgresql": "71ad5cceb4fd8e86446cf461", "snowflake": "ffdce71ffba2fc524a0e9de5", -"tsql": "b0fba0f56f0cfe71621226b5" +"tsql": "71ad5cceb4fd8e86446cf461" } ], [ @@ -14050,10 +14050,10 @@ "databricks": "d227b99a82e505d599c2ed8a", "duckdb": "35a9c5c1419bff507cf65ae2", "generic": "d227b99a82e505d599c2ed8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d227b99a82e505d599c2ed8a", -"postgres": "d227b99a82e505d599c2ed8a", -"postgresql": "d227b99a82e505d599c2ed8a", +"motherduck": "35a9c5c1419bff507cf65ae2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "35a9c5c1419bff507cf65ae2", +"postgresql": "35a9c5c1419bff507cf65ae2", "snowflake": "d227b99a82e505d599c2ed8a", "tsql": "d227b99a82e505d599c2ed8a" } @@ -14067,8 +14067,8 @@ "databricks": "c2700ca3573352821e09af03", "duckdb": "c2700ca3573352821e09af03", "generic": "c2700ca3573352821e09af03", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c2700ca3573352821e09af03", +"motherduck": "c2700ca3573352821e09af03", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c2700ca3573352821e09af03", "postgresql": "c2700ca3573352821e09af03", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -14084,8 +14084,8 @@ "databricks": "3915f3f73328f0838497b2d5", "duckdb": "3915f3f73328f0838497b2d5", "generic": "3915f3f73328f0838497b2d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3915f3f73328f0838497b2d5", +"motherduck": "3915f3f73328f0838497b2d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3915f3f73328f0838497b2d5", "postgresql": "3915f3f73328f0838497b2d5", "snowflake": "f43dac38f34a1c0618a3f812", @@ -14101,8 +14101,8 @@ "databricks": "0703bf71a54942bdaa28406e", "duckdb": "0703bf71a54942bdaa28406e", "generic": "0703bf71a54942bdaa28406e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0703bf71a54942bdaa28406e", +"motherduck": "0703bf71a54942bdaa28406e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0703bf71a54942bdaa28406e", "postgresql": "0703bf71a54942bdaa28406e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -14118,8 +14118,8 @@ "databricks": "b55b02912e30e27dcb40ad93", "duckdb": "b55b02912e30e27dcb40ad93", "generic": "b55b02912e30e27dcb40ad93", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b55b02912e30e27dcb40ad93", +"motherduck": "b55b02912e30e27dcb40ad93", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b55b02912e30e27dcb40ad93", "postgresql": "b55b02912e30e27dcb40ad93", "snowflake": "b55b02912e30e27dcb40ad93", @@ -14135,8 +14135,8 @@ "databricks": "3688fe25b8bdff7eb938e6f9", "duckdb": "e8cd7a4caa15ec2b6f990a1f", "generic": "1757eadf86c2a8956b520868", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3688fe25b8bdff7eb938e6f9", +"motherduck": "e8cd7a4caa15ec2b6f990a1f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8cd7a4caa15ec2b6f990a1f", "postgresql": "e8cd7a4caa15ec2b6f990a1f", "snowflake": "fe491937bc4ec7b061f2be43", @@ -14152,10 +14152,10 @@ "databricks": "c6106f30f23f392e17eadef4", "duckdb": "c6106f30f23f392e17eadef4", "generic": "c6106f30f23f392e17eadef4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6106f30f23f392e17eadef4", -"postgres": "c6106f30f23f392e17eadef4", -"postgresql": "c6106f30f23f392e17eadef4", +"motherduck": "c6106f30f23f392e17eadef4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f43dac38f34a1c0618a3f812", +"postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "c6106f30f23f392e17eadef4", "tsql": "c6106f30f23f392e17eadef4" } @@ -14165,12 +14165,12 @@ { "DuckDB": "eb9c0f675dd300eb82500b21", "None": "eb9c0f675dd300eb82500b21", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "eb9c0f675dd300eb82500b21", "duckdb": "eb9c0f675dd300eb82500b21", "generic": "eb9c0f675dd300eb82500b21", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "eb9c0f675dd300eb82500b21", +"motherduck": "eb9c0f675dd300eb82500b21", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "eb9c0f675dd300eb82500b21", "postgresql": "eb9c0f675dd300eb82500b21", "snowflake": "4e24a80b20b9dee0cbbfac17", @@ -14186,8 +14186,8 @@ "databricks": "3eb44072dafa3bef75c97b6a", "duckdb": "3eb44072dafa3bef75c97b6a", "generic": "3eb44072dafa3bef75c97b6a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3eb44072dafa3bef75c97b6a", +"motherduck": "3eb44072dafa3bef75c97b6a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3eb44072dafa3bef75c97b6a", "postgresql": "3eb44072dafa3bef75c97b6a", "snowflake": "3eb44072dafa3bef75c97b6a", @@ -14199,12 +14199,12 @@ { "DuckDB": "461923a0d34defd0c726d6e5", "None": "461923a0d34defd0c726d6e5", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "461923a0d34defd0c726d6e5", "duckdb": "461923a0d34defd0c726d6e5", "generic": "461923a0d34defd0c726d6e5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "461923a0d34defd0c726d6e5", +"motherduck": "461923a0d34defd0c726d6e5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "461923a0d34defd0c726d6e5", "postgresql": "461923a0d34defd0c726d6e5", "snowflake": "461923a0d34defd0c726d6e5", @@ -14215,17 +14215,17 @@ "type", { "DuckDB": "f2ed52f6bf46b4db9343551c", -"None": "f2ed52f6bf46b4db9343551c", -"bigquery": "f10bdd4d40eb495cbcecd31d", -"databricks": "f2ed52f6bf46b4db9343551c", +"None": "3f998a9ab68d8b2514840489", +"bigquery": "1e75e5227bea0ae294ac7af1", +"databricks": "3f998a9ab68d8b2514840489", "duckdb": "f2ed52f6bf46b4db9343551c", -"generic": "f2ed52f6bf46b4db9343551c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f2ed52f6bf46b4db9343551c", -"postgres": "f2ed52f6bf46b4db9343551c", -"postgresql": "f2ed52f6bf46b4db9343551c", +"generic": "3f998a9ab68d8b2514840489", +"motherduck": "f2ed52f6bf46b4db9343551c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3f998a9ab68d8b2514840489", +"postgresql": "3f998a9ab68d8b2514840489", "snowflake": "f2ed52f6bf46b4db9343551c", -"tsql": "f2ed52f6bf46b4db9343551c" +"tsql": "3f998a9ab68d8b2514840489" } ], [ @@ -14237,10 +14237,10 @@ "databricks": "0960c90223e1eca15361360f", "duckdb": "0960c90223e1eca15361360f", "generic": "0960c90223e1eca15361360f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0960c90223e1eca15361360f", -"postgres": "0960c90223e1eca15361360f", -"postgresql": "0960c90223e1eca15361360f", +"motherduck": "0960c90223e1eca15361360f", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "b72367ce0764c938c620a44c", +"postgresql": "b72367ce0764c938c620a44c", "snowflake": "0960c90223e1eca15361360f", "tsql": "0960c90223e1eca15361360f" } @@ -14254,10 +14254,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -14271,8 +14271,8 @@ "databricks": "11d8d18c76077fddaf1b264f", "duckdb": "11d8d18c76077fddaf1b264f", "generic": "11d8d18c76077fddaf1b264f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "11d8d18c76077fddaf1b264f", +"motherduck": "11d8d18c76077fddaf1b264f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "11d8d18c76077fddaf1b264f", "postgresql": "11d8d18c76077fddaf1b264f", "snowflake": "11d8d18c76077fddaf1b264f", @@ -14288,8 +14288,8 @@ "databricks": "0b9d9879e289ea9a6a3e3e70", "duckdb": "0b9d9879e289ea9a6a3e3e70", "generic": "0b9d9879e289ea9a6a3e3e70", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0b9d9879e289ea9a6a3e3e70", +"motherduck": "0b9d9879e289ea9a6a3e3e70", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0b9d9879e289ea9a6a3e3e70", "postgresql": "0b9d9879e289ea9a6a3e3e70", "snowflake": "0b9d9879e289ea9a6a3e3e70", @@ -14305,8 +14305,8 @@ "databricks": "8e484ef176389314b9fd318e", "duckdb": "8e484ef176389314b9fd318e", "generic": "8e484ef176389314b9fd318e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8e484ef176389314b9fd318e", +"motherduck": "8e484ef176389314b9fd318e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8e484ef176389314b9fd318e", "postgresql": "8e484ef176389314b9fd318e", "snowflake": "8e484ef176389314b9fd318e", @@ -14322,8 +14322,8 @@ "databricks": "41a317d0625259b54aa1dc94", "duckdb": "41a317d0625259b54aa1dc94", "generic": "41a317d0625259b54aa1dc94", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "41a317d0625259b54aa1dc94", +"motherduck": "41a317d0625259b54aa1dc94", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "41a317d0625259b54aa1dc94", "postgresql": "41a317d0625259b54aa1dc94", "snowflake": "41a317d0625259b54aa1dc94", @@ -14335,12 +14335,12 @@ { "DuckDB": "f01435c3d6e460ffd86479dc", "None": "f01435c3d6e460ffd86479dc", -"bigquery": "99d6d9358db2ff349db17bb6", +"bigquery": "01d1b160c1768fa1cd4b2e45", "databricks": "72d1587b51c517b53f52a2d8", "duckdb": "f01435c3d6e460ffd86479dc", "generic": "f01435c3d6e460ffd86479dc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f01435c3d6e460ffd86479dc", +"motherduck": "f01435c3d6e460ffd86479dc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f01435c3d6e460ffd86479dc", "postgresql": "f01435c3d6e460ffd86479dc", "snowflake": "143dfed5733eda8a7f6ed075", @@ -14356,10 +14356,10 @@ "databricks": "5d25d5e13f81700741695ed4", "duckdb": "5d25d5e13f81700741695ed4", "generic": "5d25d5e13f81700741695ed4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d25d5e13f81700741695ed4", -"postgres": "5d25d5e13f81700741695ed4", -"postgresql": "5d25d5e13f81700741695ed4", +"motherduck": "5d25d5e13f81700741695ed4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "62131fb5b065f5de2e74a0f1", +"postgresql": "62131fb5b065f5de2e74a0f1", "snowflake": "5d25d5e13f81700741695ed4", "tsql": "5d25d5e13f81700741695ed4" } @@ -14368,17 +14368,17 @@ "type", { "DuckDB": "3e2cff9b165a6eaf1c043756", -"None": "77fe8e560c0d80d58e64a3ac", -"bigquery": "77fe8e560c0d80d58e64a3ac", -"databricks": "a8b5c14299c94dad25520df6", +"None": "ea6e350a4a788066ff386c50", +"bigquery": "80ea7a56a9546d00afc1689a", +"databricks": "ea6e350a4a788066ff386c50", "duckdb": "3e2cff9b165a6eaf1c043756", -"generic": "77fe8e560c0d80d58e64a3ac", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "545b06c80ff7b812dafe5136", -"postgresql": "545b06c80ff7b812dafe5136", +"generic": "ea6e350a4a788066ff386c50", +"motherduck": "3e2cff9b165a6eaf1c043756", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ea6e350a4a788066ff386c50", +"postgresql": "ea6e350a4a788066ff386c50", "snowflake": "2a7a3265ae4026b435644d0e", -"tsql": "d1dc9a140dbe2eb1874c6ad7" +"tsql": "ea6e350a4a788066ff386c50" } ], [ @@ -14390,8 +14390,8 @@ "databricks": "adbb06204fd66d8071c3dbc6", "duckdb": "29739921db4d47abc1ac18c7", "generic": "29739921db4d47abc1ac18c7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "29739921db4d47abc1ac18c7", +"motherduck": "29739921db4d47abc1ac18c7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "29739921db4d47abc1ac18c7", "postgresql": "29739921db4d47abc1ac18c7", "snowflake": "216a7f0ead009a087eea4e1c", @@ -14407,8 +14407,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -14424,8 +14424,8 @@ "databricks": "f15c56475abfc73488abe63b", "duckdb": "f15c56475abfc73488abe63b", "generic": "f15c56475abfc73488abe63b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f15c56475abfc73488abe63b", +"motherduck": "f15c56475abfc73488abe63b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f15c56475abfc73488abe63b", "postgresql": "f15c56475abfc73488abe63b", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -14441,10 +14441,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -14454,14 +14454,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -14475,8 +14475,8 @@ "databricks": "61058ba40f23266ededb040f", "duckdb": "53ea41ce10b9fa682ddf305d", "generic": "a1176e5228f8200c23e7a0a7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "53ea41ce10b9fa682ddf305d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a09c2bcd944462f73dd87c2d", "postgresql": "a09c2bcd944462f73dd87c2d", "snowflake": "9553636ef19ebb7706dabb5f", @@ -14492,10 +14492,10 @@ "databricks": "66078c43faec49916ed11546", "duckdb": "66078c43faec49916ed11546", "generic": "66078c43faec49916ed11546", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "66078c43faec49916ed11546", -"postgres": "66078c43faec49916ed11546", -"postgresql": "66078c43faec49916ed11546", +"motherduck": "66078c43faec49916ed11546", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "48a21c33337c0a03f7f0c746", +"postgresql": "48a21c33337c0a03f7f0c746", "snowflake": "66078c43faec49916ed11546", "tsql": "66078c43faec49916ed11546" } @@ -14509,8 +14509,8 @@ "databricks": "cea3ac691106cc77e45d9414", "duckdb": "cea3ac691106cc77e45d9414", "generic": "cea3ac691106cc77e45d9414", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cea3ac691106cc77e45d9414", +"motherduck": "cea3ac691106cc77e45d9414", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cea3ac691106cc77e45d9414", "postgresql": "cea3ac691106cc77e45d9414", "snowflake": "cea3ac691106cc77e45d9414", @@ -14522,12 +14522,12 @@ { "DuckDB": "aae2b1fe6f2d9807ecde412b", "None": "aae2b1fe6f2d9807ecde412b", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "aae2b1fe6f2d9807ecde412b", "duckdb": "aae2b1fe6f2d9807ecde412b", "generic": "aae2b1fe6f2d9807ecde412b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aae2b1fe6f2d9807ecde412b", +"motherduck": "aae2b1fe6f2d9807ecde412b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "aae2b1fe6f2d9807ecde412b", "postgresql": "aae2b1fe6f2d9807ecde412b", "snowflake": "aae2b1fe6f2d9807ecde412b", @@ -14543,8 +14543,8 @@ "databricks": "937a574f550c49d90b6065cc", "duckdb": "937a574f550c49d90b6065cc", "generic": "937a574f550c49d90b6065cc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "937a574f550c49d90b6065cc", +"motherduck": "937a574f550c49d90b6065cc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "937a574f550c49d90b6065cc", "postgresql": "937a574f550c49d90b6065cc", "snowflake": "937a574f550c49d90b6065cc", @@ -14560,8 +14560,8 @@ "databricks": "ce156bc49d99761b01d1c550", "duckdb": "ce156bc49d99761b01d1c550", "generic": "ce156bc49d99761b01d1c550", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ce156bc49d99761b01d1c550", +"motherduck": "ce156bc49d99761b01d1c550", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ce156bc49d99761b01d1c550", "postgresql": "ce156bc49d99761b01d1c550", "snowflake": "ce156bc49d99761b01d1c550", @@ -14577,8 +14577,8 @@ "databricks": "2cc8cf0f153f72622d15048c", "duckdb": "2cc8cf0f153f72622d15048c", "generic": "2cc8cf0f153f72622d15048c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2cc8cf0f153f72622d15048c", +"motherduck": "2cc8cf0f153f72622d15048c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2cc8cf0f153f72622d15048c", "postgresql": "2cc8cf0f153f72622d15048c", "snowflake": "2cc8cf0f153f72622d15048c", @@ -14594,8 +14594,8 @@ "databricks": "ba72bc162859c1861cc127e7", "duckdb": "ba72bc162859c1861cc127e7", "generic": "ba72bc162859c1861cc127e7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ba72bc162859c1861cc127e7", +"motherduck": "ba72bc162859c1861cc127e7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ba72bc162859c1861cc127e7", "postgresql": "ba72bc162859c1861cc127e7", "snowflake": "ba72bc162859c1861cc127e7", @@ -14611,8 +14611,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -14628,8 +14628,8 @@ "databricks": "c2a3a3c3789aeea50e8c4f35", "duckdb": "c2a3a3c3789aeea50e8c4f35", "generic": "c2a3a3c3789aeea50e8c4f35", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c2a3a3c3789aeea50e8c4f35", +"motherduck": "c2a3a3c3789aeea50e8c4f35", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c2a3a3c3789aeea50e8c4f35", "postgresql": "c2a3a3c3789aeea50e8c4f35", "snowflake": "c2a3a3c3789aeea50e8c4f35", @@ -14645,10 +14645,10 @@ "databricks": "054898738769701df3abbf2e", "duckdb": "16c4b7f3bdc7c21a00a78838", "generic": "054898738769701df3abbf2e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "054898738769701df3abbf2e", -"postgres": "054898738769701df3abbf2e", -"postgresql": "054898738769701df3abbf2e", +"motherduck": "16c4b7f3bdc7c21a00a78838", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "16c4b7f3bdc7c21a00a78838", +"postgresql": "16c4b7f3bdc7c21a00a78838", "snowflake": "054898738769701df3abbf2e", "tsql": "054898738769701df3abbf2e" } @@ -14662,10 +14662,10 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "b0b09c4a6f7570ece56f59ce", "generic": "b0b09c4a6f7570ece56f59ce", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "355e032cc5c0f24695836b3d", -"postgres": "b0b09c4a6f7570ece56f59ce", -"postgresql": "b0b09c4a6f7570ece56f59ce", +"motherduck": "b0b09c4a6f7570ece56f59ce", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "111af35848fe500ec2ae54b2", +"postgresql": "111af35848fe500ec2ae54b2", "snowflake": "355e032cc5c0f24695836b3d", "tsql": "b0b09c4a6f7570ece56f59ce" } @@ -14679,8 +14679,8 @@ "databricks": "e8a5e051bb567983c365b3fd", "duckdb": "e8a5e051bb567983c365b3fd", "generic": "e8a5e051bb567983c365b3fd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e8a5e051bb567983c365b3fd", +"motherduck": "e8a5e051bb567983c365b3fd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8a5e051bb567983c365b3fd", "postgresql": "e8a5e051bb567983c365b3fd", "snowflake": "b210f8eb26c37b422f786c6b", @@ -14696,8 +14696,8 @@ "databricks": "207b6dc5f2a2547137393792", "duckdb": "50563fc19d4ed8ceb4f5e8e4", "generic": "50563fc19d4ed8ceb4f5e8e4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "50563fc19d4ed8ceb4f5e8e4", +"motherduck": "50563fc19d4ed8ceb4f5e8e4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8770742a4fe26efe6bd47a00", "postgresql": "8770742a4fe26efe6bd47a00", "snowflake": "a4cd3eca76c356ecd633fe7b", @@ -14713,10 +14713,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -14730,8 +14730,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -14747,8 +14747,8 @@ "databricks": "77ffdb80029bd6e2cca768ad", "duckdb": "77ffdb80029bd6e2cca768ad", "generic": "77ffdb80029bd6e2cca768ad", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "77ffdb80029bd6e2cca768ad", +"motherduck": "77ffdb80029bd6e2cca768ad", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "77ffdb80029bd6e2cca768ad", "postgresql": "77ffdb80029bd6e2cca768ad", "snowflake": "77ffdb80029bd6e2cca768ad", @@ -14764,8 +14764,8 @@ "databricks": "c37de6584758b2433c289aee", "duckdb": "c37de6584758b2433c289aee", "generic": "c37de6584758b2433c289aee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c37de6584758b2433c289aee", +"motherduck": "c37de6584758b2433c289aee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c37de6584758b2433c289aee", "postgresql": "c37de6584758b2433c289aee", "snowflake": "c37de6584758b2433c289aee", @@ -14781,8 +14781,8 @@ "databricks": "555111267818cbd3d0b07105", "duckdb": "555111267818cbd3d0b07105", "generic": "555111267818cbd3d0b07105", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "555111267818cbd3d0b07105", +"motherduck": "555111267818cbd3d0b07105", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "555111267818cbd3d0b07105", "postgresql": "555111267818cbd3d0b07105", "snowflake": "555111267818cbd3d0b07105", @@ -14798,8 +14798,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -14815,10 +14815,10 @@ "databricks": "3c0719ca5c83e0a20d0b0b42", "duckdb": "42d4a23d9a52e79d0c3458d3", "generic": "3c0719ca5c83e0a20d0b0b42", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3c0719ca5c83e0a20d0b0b42", -"postgres": "3c0719ca5c83e0a20d0b0b42", -"postgresql": "3c0719ca5c83e0a20d0b0b42", +"motherduck": "42d4a23d9a52e79d0c3458d3", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "42d4a23d9a52e79d0c3458d3", +"postgresql": "42d4a23d9a52e79d0c3458d3", "snowflake": "a3acd7ba35e81a800f967bd3", "tsql": "3c0719ca5c83e0a20d0b0b42" } @@ -14828,12 +14828,12 @@ { "DuckDB": "aae2b1fe6f2d9807ecde412b", "None": "aae2b1fe6f2d9807ecde412b", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "aae2b1fe6f2d9807ecde412b", "duckdb": "aae2b1fe6f2d9807ecde412b", "generic": "aae2b1fe6f2d9807ecde412b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aae2b1fe6f2d9807ecde412b", +"motherduck": "aae2b1fe6f2d9807ecde412b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "aae2b1fe6f2d9807ecde412b", "postgresql": "aae2b1fe6f2d9807ecde412b", "snowflake": "aae2b1fe6f2d9807ecde412b", @@ -14849,8 +14849,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -14861,34 +14861,34 @@ "type", { "DuckDB": "919b7ec6a7b49d8527b784cd", -"None": "919b7ec6a7b49d8527b784cd", -"bigquery": "204206d1d1eecf007966cc5b", -"databricks": "e3bc1b8bad22d8104417b00f", +"None": "558da38ec4d9d5d6c72f60cf", +"bigquery": "c50a316d091c821866e4bfba", +"databricks": "558da38ec4d9d5d6c72f60cf", "duckdb": "919b7ec6a7b49d8527b784cd", -"generic": "919b7ec6a7b49d8527b784cd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "919b7ec6a7b49d8527b784cd", -"postgres": "a3b6b25265be330ec52a3322", -"postgresql": "a3b6b25265be330ec52a3322", +"generic": "558da38ec4d9d5d6c72f60cf", +"motherduck": "919b7ec6a7b49d8527b784cd", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "558da38ec4d9d5d6c72f60cf", +"postgresql": "558da38ec4d9d5d6c72f60cf", "snowflake": "919b7ec6a7b49d8527b784cd", -"tsql": "919b7ec6a7b49d8527b784cd" +"tsql": "558da38ec4d9d5d6c72f60cf" } ], [ "type", { "DuckDB": "a428302e4848ffe877284c84", -"None": "a428302e4848ffe877284c84", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "a428302e4848ffe877284c84", +"None": "c9b810639795a7bfab91b98d", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "c9b810639795a7bfab91b98d", "duckdb": "a428302e4848ffe877284c84", -"generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"generic": "c9b810639795a7bfab91b98d", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "a428302e4848ffe877284c84" +"tsql": "c9b810639795a7bfab91b98d" } ], [ @@ -14900,8 +14900,8 @@ "databricks": "5fd024c2193505b62de9c162", "duckdb": "5fd024c2193505b62de9c162", "generic": "5fd024c2193505b62de9c162", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5fd024c2193505b62de9c162", +"motherduck": "5fd024c2193505b62de9c162", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5fd024c2193505b62de9c162", "postgresql": "5fd024c2193505b62de9c162", "snowflake": "5fd024c2193505b62de9c162", @@ -14913,14 +14913,14 @@ { "DuckDB": "4b356542044f1267fcfc487a", "None": "4b356542044f1267fcfc487a", -"bigquery": "4b356542044f1267fcfc487a", +"bigquery": "a5656d70e208254d1d3e9b4f", "databricks": "4b356542044f1267fcfc487a", "duckdb": "4b356542044f1267fcfc487a", "generic": "4b356542044f1267fcfc487a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4b356542044f1267fcfc487a", -"postgres": "4b356542044f1267fcfc487a", -"postgresql": "4b356542044f1267fcfc487a", +"motherduck": "4b356542044f1267fcfc487a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a5656d70e208254d1d3e9b4f", +"postgresql": "a5656d70e208254d1d3e9b4f", "snowflake": "4b356542044f1267fcfc487a", "tsql": "4b356542044f1267fcfc487a" } @@ -14934,8 +14934,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -14951,8 +14951,8 @@ "databricks": "6bd27be6a47ef34ec1defbad", "duckdb": "b0791f9f270e764eeeb6fb8e", "generic": "c7c38fdeaeb7858a44976f1d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c7c38fdeaeb7858a44976f1d", +"motherduck": "b0791f9f270e764eeeb6fb8e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4d7604d41e3585ec187dec82", "postgresql": "4d7604d41e3585ec187dec82", "snowflake": "c7c38fdeaeb7858a44976f1d", @@ -14968,8 +14968,8 @@ "databricks": "66bffd006fc7638db82257d2", "duckdb": "66bffd006fc7638db82257d2", "generic": "66bffd006fc7638db82257d2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "66bffd006fc7638db82257d2", +"motherduck": "66bffd006fc7638db82257d2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "66bffd006fc7638db82257d2", "postgresql": "66bffd006fc7638db82257d2", "snowflake": "66bffd006fc7638db82257d2", @@ -14985,8 +14985,8 @@ "databricks": "f43dac38f34a1c0618a3f812", "duckdb": "f43dac38f34a1c0618a3f812", "generic": "f43dac38f34a1c0618a3f812", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f43dac38f34a1c0618a3f812", +"motherduck": "f43dac38f34a1c0618a3f812", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f43dac38f34a1c0618a3f812", "postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "f43dac38f34a1c0618a3f812", @@ -14998,14 +14998,14 @@ { "DuckDB": "5d25d5e13f81700741695ed4", "None": "5d25d5e13f81700741695ed4", -"bigquery": "23ee196b7bd6039855a1460f", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "5d25d5e13f81700741695ed4", "duckdb": "5d25d5e13f81700741695ed4", "generic": "5d25d5e13f81700741695ed4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d25d5e13f81700741695ed4", -"postgres": "5d25d5e13f81700741695ed4", -"postgresql": "5d25d5e13f81700741695ed4", +"motherduck": "5d25d5e13f81700741695ed4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "62131fb5b065f5de2e74a0f1", +"postgresql": "62131fb5b065f5de2e74a0f1", "snowflake": "5d25d5e13f81700741695ed4", "tsql": "5d25d5e13f81700741695ed4" } @@ -15019,8 +15019,8 @@ "databricks": "52928fec41d9097d054cb63d", "duckdb": "52928fec41d9097d054cb63d", "generic": "52928fec41d9097d054cb63d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "52928fec41d9097d054cb63d", +"motherduck": "52928fec41d9097d054cb63d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "52928fec41d9097d054cb63d", "postgresql": "52928fec41d9097d054cb63d", "snowflake": "52928fec41d9097d054cb63d", @@ -15032,14 +15032,14 @@ { "DuckDB": "b561884132dbe7e42b719110", "None": "b561884132dbe7e42b719110", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "b561884132dbe7e42b719110", "duckdb": "b561884132dbe7e42b719110", "generic": "b561884132dbe7e42b719110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b561884132dbe7e42b719110", -"postgres": "b561884132dbe7e42b719110", -"postgresql": "b561884132dbe7e42b719110", +"motherduck": "b561884132dbe7e42b719110", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5aa51d84ac5e6c7a9306f348", +"postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "b561884132dbe7e42b719110", "tsql": "b561884132dbe7e42b719110" } @@ -15047,14 +15047,14 @@ [ "type", { -"DuckDB": "c6654395c62d21b415299f72", +"DuckDB": "0712c33a016f7dd6a37ee011", "None": "c6654395c62d21b415299f72", "bigquery": "0712c33a016f7dd6a37ee011", "databricks": "c6654395c62d21b415299f72", -"duckdb": "c6654395c62d21b415299f72", +"duckdb": "0712c33a016f7dd6a37ee011", "generic": "c6654395c62d21b415299f72", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2978a8fe925c7f93c6e9fcfb", +"motherduck": "0712c33a016f7dd6a37ee011", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6654395c62d21b415299f72", "postgresql": "c6654395c62d21b415299f72", "snowflake": "0712c33a016f7dd6a37ee011", @@ -15066,12 +15066,12 @@ { "DuckDB": "2ffee1a4ca7dc4a711fc0d27", "None": "2ffee1a4ca7dc4a711fc0d27", -"bigquery": "2ffee1a4ca7dc4a711fc0d27", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "2ffee1a4ca7dc4a711fc0d27", "duckdb": "2ffee1a4ca7dc4a711fc0d27", "generic": "2ffee1a4ca7dc4a711fc0d27", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2ffee1a4ca7dc4a711fc0d27", +"motherduck": "2ffee1a4ca7dc4a711fc0d27", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2ffee1a4ca7dc4a711fc0d27", "postgresql": "2ffee1a4ca7dc4a711fc0d27", "snowflake": "2ffee1a4ca7dc4a711fc0d27", @@ -15087,8 +15087,8 @@ "databricks": "c6889f2965db73017be6f6e7", "duckdb": "c6889f2965db73017be6f6e7", "generic": "c6889f2965db73017be6f6e7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6889f2965db73017be6f6e7", +"motherduck": "c6889f2965db73017be6f6e7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6889f2965db73017be6f6e7", "postgresql": "c6889f2965db73017be6f6e7", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -15104,10 +15104,10 @@ "databricks": "de89632e277dbc8c97115419", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -15121,8 +15121,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -15135,11 +15135,11 @@ "DuckDB": "9c2cff8be7225cf79883ca65", "None": "9c2cff8be7225cf79883ca65", "bigquery": "9c2cff8be7225cf79883ca65", -"databricks": "901ac89f8d9ec18bd3a61e4b", +"databricks": "9c2cff8be7225cf79883ca65", "duckdb": "9c2cff8be7225cf79883ca65", "generic": "9c2cff8be7225cf79883ca65", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "901ac89f8d9ec18bd3a61e4b", +"motherduck": "9c2cff8be7225cf79883ca65", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9c2cff8be7225cf79883ca65", "postgresql": "9c2cff8be7225cf79883ca65", "snowflake": "9c2cff8be7225cf79883ca65", @@ -15155,10 +15155,10 @@ "databricks": "ab62f43260f32e2cf62666fc", "duckdb": "0baaca265927140414f32b37", "generic": "ab62f43260f32e2cf62666fc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ab62f43260f32e2cf62666fc", -"postgres": "ab62f43260f32e2cf62666fc", -"postgresql": "ab62f43260f32e2cf62666fc", +"motherduck": "0baaca265927140414f32b37", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9ea4932505663b43f527adad", +"postgresql": "9ea4932505663b43f527adad", "snowflake": "ab62f43260f32e2cf62666fc", "tsql": "ab62f43260f32e2cf62666fc" } @@ -15172,8 +15172,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -15185,12 +15185,12 @@ { "DuckDB": "97e5335218efead1a4226b8d", "None": "97e5335218efead1a4226b8d", -"bigquery": "97e5335218efead1a4226b8d", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "97e5335218efead1a4226b8d", "duckdb": "97e5335218efead1a4226b8d", "generic": "97e5335218efead1a4226b8d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "97e5335218efead1a4226b8d", +"motherduck": "97e5335218efead1a4226b8d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "97e5335218efead1a4226b8d", "postgresql": "97e5335218efead1a4226b8d", "snowflake": "97e5335218efead1a4226b8d", @@ -15202,14 +15202,14 @@ { "DuckDB": "ee47e1424cb01deb0cf51760", "None": "ee47e1424cb01deb0cf51760", -"bigquery": "ee47e1424cb01deb0cf51760", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "ee47e1424cb01deb0cf51760", "duckdb": "ee47e1424cb01deb0cf51760", "generic": "ee47e1424cb01deb0cf51760", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ee47e1424cb01deb0cf51760", -"postgres": "ee47e1424cb01deb0cf51760", -"postgresql": "ee47e1424cb01deb0cf51760", +"motherduck": "ee47e1424cb01deb0cf51760", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3c1521654088dd54d0dc9ead", +"postgresql": "3c1521654088dd54d0dc9ead", "snowflake": "ee47e1424cb01deb0cf51760", "tsql": "ee47e1424cb01deb0cf51760" } @@ -15219,12 +15219,12 @@ { "DuckDB": "2d4aea8dec5521e258596f3d", "None": "2d4aea8dec5521e258596f3d", -"bigquery": "2d4aea8dec5521e258596f3d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "2d4aea8dec5521e258596f3d", "duckdb": "2d4aea8dec5521e258596f3d", "generic": "2d4aea8dec5521e258596f3d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2d4aea8dec5521e258596f3d", +"motherduck": "2d4aea8dec5521e258596f3d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f15c56475abfc73488abe63b", "postgresql": "f15c56475abfc73488abe63b", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -15240,8 +15240,8 @@ "databricks": "8917b70db141a02ac2e2bb1e", "duckdb": "8917b70db141a02ac2e2bb1e", "generic": "8917b70db141a02ac2e2bb1e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8917b70db141a02ac2e2bb1e", +"motherduck": "8917b70db141a02ac2e2bb1e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8917b70db141a02ac2e2bb1e", "postgresql": "8917b70db141a02ac2e2bb1e", "snowflake": "8917b70db141a02ac2e2bb1e", @@ -15257,8 +15257,8 @@ "databricks": "ef480cafe4d260b70ce5214c", "duckdb": "ef480cafe4d260b70ce5214c", "generic": "ef480cafe4d260b70ce5214c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ef480cafe4d260b70ce5214c", +"motherduck": "ef480cafe4d260b70ce5214c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ef480cafe4d260b70ce5214c", "postgresql": "ef480cafe4d260b70ce5214c", "snowflake": "ef480cafe4d260b70ce5214c", @@ -15269,17 +15269,17 @@ "type", { "DuckDB": "19bdd92ea0cc5fb028657510", -"None": "78b2cf275c640af54feeca31", -"bigquery": "1e75e5227bea0ae294ac7af1", -"databricks": "1e75e5227bea0ae294ac7af1", +"None": "8075663faec01d3abb4fc153", +"bigquery": "8075663faec01d3abb4fc153", +"databricks": "8075663faec01d3abb4fc153", "duckdb": "19bdd92ea0cc5fb028657510", -"generic": "78b2cf275c640af54feeca31", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19bdd92ea0cc5fb028657510", -"postgres": "78b2cf275c640af54feeca31", -"postgresql": "78b2cf275c640af54feeca31", +"generic": "8075663faec01d3abb4fc153", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8075663faec01d3abb4fc153", +"postgresql": "8075663faec01d3abb4fc153", "snowflake": "8ff614b7306c0edbe36ce00b", -"tsql": "78b2cf275c640af54feeca31" +"tsql": "8075663faec01d3abb4fc153" } ], [ @@ -15287,14 +15287,14 @@ { "DuckDB": "ee47e1424cb01deb0cf51760", "None": "ee47e1424cb01deb0cf51760", -"bigquery": "ee47e1424cb01deb0cf51760", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "ee47e1424cb01deb0cf51760", "duckdb": "ee47e1424cb01deb0cf51760", "generic": "ee47e1424cb01deb0cf51760", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ee47e1424cb01deb0cf51760", -"postgres": "ee47e1424cb01deb0cf51760", -"postgresql": "ee47e1424cb01deb0cf51760", +"motherduck": "ee47e1424cb01deb0cf51760", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3c1521654088dd54d0dc9ead", +"postgresql": "3c1521654088dd54d0dc9ead", "snowflake": "ee47e1424cb01deb0cf51760", "tsql": "ee47e1424cb01deb0cf51760" } @@ -15308,8 +15308,8 @@ "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "aab0389e2b5470136660bf8a", "postgresql": "aab0389e2b5470136660bf8a", "snowflake": "97a20344d811fb77c7690863", @@ -15321,14 +15321,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -15342,10 +15342,10 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "61d08c878cc506dd91ca4586", "generic": "61d08c878cc506dd91ca4586", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c100cdbd268164cf084295be", -"postgres": "61d08c878cc506dd91ca4586", -"postgresql": "61d08c878cc506dd91ca4586", +"motherduck": "61d08c878cc506dd91ca4586", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "111af35848fe500ec2ae54b2", +"postgresql": "111af35848fe500ec2ae54b2", "snowflake": "c100cdbd268164cf084295be", "tsql": "61d08c878cc506dd91ca4586" } @@ -15359,8 +15359,8 @@ "databricks": "41ae0d23941c87be23d59e1f", "duckdb": "755657fbcced1de4551fb370", "generic": "41ae0d23941c87be23d59e1f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "41ae0d23941c87be23d59e1f", +"motherduck": "755657fbcced1de4551fb370", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "41ae0d23941c87be23d59e1f", "postgresql": "41ae0d23941c87be23d59e1f", "snowflake": "41ae0d23941c87be23d59e1f", @@ -15376,8 +15376,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -15393,8 +15393,8 @@ "databricks": "251aba3fef503ce64556c701", "duckdb": "251aba3fef503ce64556c701", "generic": "251aba3fef503ce64556c701", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "251aba3fef503ce64556c701", +"motherduck": "251aba3fef503ce64556c701", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "251aba3fef503ce64556c701", "postgresql": "251aba3fef503ce64556c701", "snowflake": "c50a316d091c821866e4bfba", @@ -15410,8 +15410,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -15427,8 +15427,8 @@ "databricks": "c82815abe30b3d099903f838", "duckdb": "c82815abe30b3d099903f838", "generic": "c82815abe30b3d099903f838", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c82815abe30b3d099903f838", +"motherduck": "c82815abe30b3d099903f838", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c82815abe30b3d099903f838", "postgresql": "c82815abe30b3d099903f838", "snowflake": "c82815abe30b3d099903f838", @@ -15444,8 +15444,8 @@ "databricks": "d6e37cd37419bfb26e09b080", "duckdb": "d6e37cd37419bfb26e09b080", "generic": "d6e37cd37419bfb26e09b080", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d6e37cd37419bfb26e09b080", +"motherduck": "d6e37cd37419bfb26e09b080", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d6e37cd37419bfb26e09b080", "postgresql": "d6e37cd37419bfb26e09b080", "snowflake": "d6e37cd37419bfb26e09b080", @@ -15457,12 +15457,12 @@ { "DuckDB": "5c28019dce48a74708c90a76", "None": "5c28019dce48a74708c90a76", -"bigquery": "f28a96f0eb38ad8874f6ec5d", +"bigquery": "5c28019dce48a74708c90a76", "databricks": "5c28019dce48a74708c90a76", "duckdb": "5c28019dce48a74708c90a76", "generic": "5c28019dce48a74708c90a76", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "5c28019dce48a74708c90a76", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5c28019dce48a74708c90a76", "postgresql": "5c28019dce48a74708c90a76", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -15478,8 +15478,8 @@ "databricks": "f4c43a87a78970bca1f88b09", "duckdb": "f4c43a87a78970bca1f88b09", "generic": "f4c43a87a78970bca1f88b09", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f4c43a87a78970bca1f88b09", +"motherduck": "f4c43a87a78970bca1f88b09", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f4c43a87a78970bca1f88b09", "postgresql": "f4c43a87a78970bca1f88b09", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -15495,10 +15495,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -15512,8 +15512,8 @@ "databricks": "9070740b5c7f7fb5d091ad05", "duckdb": "9070740b5c7f7fb5d091ad05", "generic": "9070740b5c7f7fb5d091ad05", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9070740b5c7f7fb5d091ad05", +"motherduck": "9070740b5c7f7fb5d091ad05", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9070740b5c7f7fb5d091ad05", "postgresql": "9070740b5c7f7fb5d091ad05", "snowflake": "9070740b5c7f7fb5d091ad05", @@ -15529,10 +15529,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -15546,8 +15546,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -15558,15 +15558,15 @@ "type", { "DuckDB": "c0eec31620dfc2ac0028173d", -"None": "7f902bdd94be27212c27de4d", -"bigquery": "02e0b2ed25f32a8d09350a23", -"databricks": "7f902bdd94be27212c27de4d", +"None": "bf34c743a59d7c3f212cf17b", +"bigquery": "bf34c743a59d7c3f212cf17b", +"databricks": "bf34c743a59d7c3f212cf17b", "duckdb": "c0eec31620dfc2ac0028173d", -"generic": "7f902bdd94be27212c27de4d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "6d562c54c27c6810625f7693", -"postgresql": "6d562c54c27c6810625f7693", +"generic": "bf34c743a59d7c3f212cf17b", +"motherduck": "c0eec31620dfc2ac0028173d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "759df854baf67e256ec19adb", +"postgresql": "759df854baf67e256ec19adb", "snowflake": "354dee69d4f0c63cf79046ac", "tsql": "bf34c743a59d7c3f212cf17b" } @@ -15580,8 +15580,8 @@ "databricks": "6cffd1617edd6454241ee732", "duckdb": "6cffd1617edd6454241ee732", "generic": "6cffd1617edd6454241ee732", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6cffd1617edd6454241ee732", +"motherduck": "6cffd1617edd6454241ee732", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6cffd1617edd6454241ee732", "postgresql": "6cffd1617edd6454241ee732", "snowflake": "6cffd1617edd6454241ee732", @@ -15597,8 +15597,8 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "111af35848fe500ec2ae54b2", "generic": "111af35848fe500ec2ae54b2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e3bc1b8bad22d8104417b00f", +"motherduck": "111af35848fe500ec2ae54b2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "111af35848fe500ec2ae54b2", "postgresql": "111af35848fe500ec2ae54b2", "snowflake": "e3bc1b8bad22d8104417b00f", @@ -15614,8 +15614,8 @@ "databricks": "e4f0244beaa01667e80482b6", "duckdb": "a766fea06fc070b352976b0a", "generic": "a766fea06fc070b352976b0a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e4f0244beaa01667e80482b6", +"motherduck": "a766fea06fc070b352976b0a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a766fea06fc070b352976b0a", "postgresql": "a766fea06fc070b352976b0a", "snowflake": "a766fea06fc070b352976b0a", @@ -15631,8 +15631,8 @@ "databricks": "6a912271e85e6d85c1238bc0", "duckdb": "6a912271e85e6d85c1238bc0", "generic": "6a912271e85e6d85c1238bc0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6a912271e85e6d85c1238bc0", +"motherduck": "6a912271e85e6d85c1238bc0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6a912271e85e6d85c1238bc0", "postgresql": "6a912271e85e6d85c1238bc0", "snowflake": "6a912271e85e6d85c1238bc0", @@ -15648,10 +15648,10 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "3efe8bb57c98fcbe74096b3c", "generic": "3efe8bb57c98fcbe74096b3c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1d8b945fd793ecdcacb90c21", -"postgres": "3efe8bb57c98fcbe74096b3c", -"postgresql": "3efe8bb57c98fcbe74096b3c", +"motherduck": "3efe8bb57c98fcbe74096b3c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "111af35848fe500ec2ae54b2", +"postgresql": "111af35848fe500ec2ae54b2", "snowflake": "1d8b945fd793ecdcacb90c21", "tsql": "3efe8bb57c98fcbe74096b3c" } @@ -15660,17 +15660,17 @@ "type", { "DuckDB": "c50a316d091c821866e4bfba", -"None": "c50a316d091c821866e4bfba", -"bigquery": "c50a316d091c821866e4bfba", -"databricks": "c50a316d091c821866e4bfba", +"None": "e6ffdece2977be55da73b59a", +"bigquery": "e6ffdece2977be55da73b59a", +"databricks": "e6ffdece2977be55da73b59a", "duckdb": "c50a316d091c821866e4bfba", -"generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"generic": "e6ffdece2977be55da73b59a", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", -"tsql": "c50a316d091c821866e4bfba" +"tsql": "e6ffdece2977be55da73b59a" } ], [ @@ -15682,10 +15682,10 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "b8321619b794db091c9e96a1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b8321619b794db091c9e96a1", -"postgres": "b8321619b794db091c9e96a1", -"postgresql": "b8321619b794db091c9e96a1", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "bce26544873d6ec9191c9a86", +"postgresql": "bce26544873d6ec9191c9a86", "snowflake": "b8321619b794db091c9e96a1", "tsql": "b8321619b794db091c9e96a1" } @@ -15694,17 +15694,17 @@ "type", { "DuckDB": "c50a316d091c821866e4bfba", -"None": "c50a316d091c821866e4bfba", -"bigquery": "c50a316d091c821866e4bfba", -"databricks": "c50a316d091c821866e4bfba", +"None": "e6ffdece2977be55da73b59a", +"bigquery": "e6ffdece2977be55da73b59a", +"databricks": "e6ffdece2977be55da73b59a", "duckdb": "c50a316d091c821866e4bfba", -"generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"generic": "e6ffdece2977be55da73b59a", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", -"tsql": "c50a316d091c821866e4bfba" +"tsql": "e6ffdece2977be55da73b59a" } ], [ @@ -15716,8 +15716,8 @@ "databricks": "8a3f094f18fb4047f0febf59", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "8a3f094f18fb4047f0febf59", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8a3f094f18fb4047f0febf59", "postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "850deea990b52b82b36a9848", @@ -15733,8 +15733,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -15746,12 +15746,12 @@ { "DuckDB": "07c9e779f7ae9c58f4f0c902", "None": "07c9e779f7ae9c58f4f0c902", -"bigquery": "07c9e779f7ae9c58f4f0c902", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "07c9e779f7ae9c58f4f0c902", "duckdb": "07c9e779f7ae9c58f4f0c902", "generic": "07c9e779f7ae9c58f4f0c902", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "07c9e779f7ae9c58f4f0c902", +"motherduck": "07c9e779f7ae9c58f4f0c902", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "07c9e779f7ae9c58f4f0c902", "postgresql": "07c9e779f7ae9c58f4f0c902", "snowflake": "07c9e779f7ae9c58f4f0c902", @@ -15767,8 +15767,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -15780,12 +15780,12 @@ { "DuckDB": "5c28019dce48a74708c90a76", "None": "5c28019dce48a74708c90a76", -"bigquery": "f28a96f0eb38ad8874f6ec5d", +"bigquery": "5c28019dce48a74708c90a76", "databricks": "5c28019dce48a74708c90a76", "duckdb": "5c28019dce48a74708c90a76", "generic": "5c28019dce48a74708c90a76", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "5c28019dce48a74708c90a76", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5c28019dce48a74708c90a76", "postgresql": "5c28019dce48a74708c90a76", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -15801,8 +15801,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -15814,12 +15814,12 @@ { "DuckDB": "e248573edaaaa875cb926c45", "None": "e248573edaaaa875cb926c45", -"bigquery": "2a0918be53051fe629d9ff8f", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "e248573edaaaa875cb926c45", "duckdb": "e248573edaaaa875cb926c45", "generic": "e248573edaaaa875cb926c45", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e248573edaaaa875cb926c45", +"motherduck": "e248573edaaaa875cb926c45", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e248573edaaaa875cb926c45", "postgresql": "e248573edaaaa875cb926c45", "snowflake": "e248573edaaaa875cb926c45", @@ -15835,8 +15835,8 @@ "databricks": "0b8ad171901cc2b7725617da", "duckdb": "0b8ad171901cc2b7725617da", "generic": "0b8ad171901cc2b7725617da", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0b8ad171901cc2b7725617da", +"motherduck": "0b8ad171901cc2b7725617da", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0b8ad171901cc2b7725617da", "postgresql": "0b8ad171901cc2b7725617da", "snowflake": "0b8ad171901cc2b7725617da", @@ -15848,12 +15848,12 @@ { "DuckDB": "d44c023c720f385769f2ab81", "None": "d44c023c720f385769f2ab81", -"bigquery": "d44c023c720f385769f2ab81", +"bigquery": "c114794e288b3464c914fd5c", "databricks": "d44c023c720f385769f2ab81", "duckdb": "d44c023c720f385769f2ab81", "generic": "d44c023c720f385769f2ab81", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d44c023c720f385769f2ab81", +"motherduck": "d44c023c720f385769f2ab81", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d44c023c720f385769f2ab81", "postgresql": "d44c023c720f385769f2ab81", "snowflake": "d44c023c720f385769f2ab81", @@ -15869,8 +15869,8 @@ "databricks": "8a3f094f18fb4047f0febf59", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "8a3f094f18fb4047f0febf59", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8a3f094f18fb4047f0febf59", "postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "850deea990b52b82b36a9848", @@ -15886,8 +15886,8 @@ "databricks": "5abf4ec799a2ec32fb10da7e", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5abf4ec799a2ec32fb10da7e", "postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -15903,8 +15903,8 @@ "databricks": "c5c5fbb0257c93153cb84430", "duckdb": "c5c5fbb0257c93153cb84430", "generic": "c5c5fbb0257c93153cb84430", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c5c5fbb0257c93153cb84430", +"motherduck": "c5c5fbb0257c93153cb84430", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c5c5fbb0257c93153cb84430", "postgresql": "c5c5fbb0257c93153cb84430", "snowflake": "c5c5fbb0257c93153cb84430", @@ -15920,8 +15920,8 @@ "databricks": "d6e37cd37419bfb26e09b080", "duckdb": "d6e37cd37419bfb26e09b080", "generic": "d6e37cd37419bfb26e09b080", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d6e37cd37419bfb26e09b080", +"motherduck": "d6e37cd37419bfb26e09b080", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d6e37cd37419bfb26e09b080", "postgresql": "d6e37cd37419bfb26e09b080", "snowflake": "d6e37cd37419bfb26e09b080", @@ -15934,11 +15934,11 @@ "DuckDB": "d34f84c1b71b9c9c0c20abb0", "None": "d34f84c1b71b9c9c0c20abb0", "bigquery": "d34f84c1b71b9c9c0c20abb0", -"databricks": "c662d9470aa4255dfb493df1", +"databricks": "d34f84c1b71b9c9c0c20abb0", "duckdb": "d34f84c1b71b9c9c0c20abb0", "generic": "d34f84c1b71b9c9c0c20abb0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c662d9470aa4255dfb493df1", +"motherduck": "d34f84c1b71b9c9c0c20abb0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d34f84c1b71b9c9c0c20abb0", "postgresql": "d34f84c1b71b9c9c0c20abb0", "snowflake": "d34f84c1b71b9c9c0c20abb0", @@ -15949,17 +15949,17 @@ "type", { "DuckDB": "c50a316d091c821866e4bfba", -"None": "c50a316d091c821866e4bfba", -"bigquery": "c50a316d091c821866e4bfba", -"databricks": "c50a316d091c821866e4bfba", +"None": "e6ffdece2977be55da73b59a", +"bigquery": "e6ffdece2977be55da73b59a", +"databricks": "e6ffdece2977be55da73b59a", "duckdb": "c50a316d091c821866e4bfba", -"generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"generic": "e6ffdece2977be55da73b59a", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", -"tsql": "c50a316d091c821866e4bfba" +"tsql": "e6ffdece2977be55da73b59a" } ], [ @@ -15971,8 +15971,8 @@ "databricks": "bbb2563edda71d0b69ef0855", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "bbb2563edda71d0b69ef0855", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "51d717b08676179ee1ccefe4", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "bbb2563edda71d0b69ef0855", "postgresql": "bbb2563edda71d0b69ef0855", "snowflake": "bbb2563edda71d0b69ef0855", @@ -15988,8 +15988,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -16005,8 +16005,8 @@ "databricks": "c1eef7499ef79562fa125447", "duckdb": "c1eef7499ef79562fa125447", "generic": "c1eef7499ef79562fa125447", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c1eef7499ef79562fa125447", +"motherduck": "c1eef7499ef79562fa125447", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c1eef7499ef79562fa125447", "postgresql": "c1eef7499ef79562fa125447", "snowflake": "c1eef7499ef79562fa125447", @@ -16022,8 +16022,8 @@ "databricks": "b210f8eb26c37b422f786c6b", "duckdb": "b210f8eb26c37b422f786c6b", "generic": "b210f8eb26c37b422f786c6b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b210f8eb26c37b422f786c6b", +"motherduck": "b210f8eb26c37b422f786c6b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b210f8eb26c37b422f786c6b", "postgresql": "b210f8eb26c37b422f786c6b", "snowflake": "b210f8eb26c37b422f786c6b", @@ -16035,12 +16035,12 @@ { "DuckDB": "2d4aea8dec5521e258596f3d", "None": "2d4aea8dec5521e258596f3d", -"bigquery": "2d4aea8dec5521e258596f3d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "2d4aea8dec5521e258596f3d", "duckdb": "2d4aea8dec5521e258596f3d", "generic": "2d4aea8dec5521e258596f3d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2d4aea8dec5521e258596f3d", +"motherduck": "2d4aea8dec5521e258596f3d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f15c56475abfc73488abe63b", "postgresql": "f15c56475abfc73488abe63b", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -16050,16 +16050,16 @@ [ "type", { -"DuckDB": "b4d65f2c9d0405e88d28938b", +"DuckDB": "0712c33a016f7dd6a37ee011", "None": "ba98b19402ac6379a4172de9", "bigquery": "ba98b19402ac6379a4172de9", "databricks": "ba98b19402ac6379a4172de9", -"duckdb": "b4d65f2c9d0405e88d28938b", +"duckdb": "0712c33a016f7dd6a37ee011", "generic": "ba98b19402ac6379a4172de9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ba98b19402ac6379a4172de9", -"postgres": "ba98b19402ac6379a4172de9", -"postgresql": "ba98b19402ac6379a4172de9", +"motherduck": "0712c33a016f7dd6a37ee011", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3aa01d5ccf0d0b7e5c540297", +"postgresql": "3aa01d5ccf0d0b7e5c540297", "snowflake": "ba98b19402ac6379a4172de9", "tsql": "ba98b19402ac6379a4172de9" } @@ -16069,14 +16069,14 @@ { "DuckDB": "e46d4be44ab9e500e9190d26", "None": "e46d4be44ab9e500e9190d26", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -16085,17 +16085,17 @@ "type", { "DuckDB": "6c58c6a62958e64e6a26bf9c", -"None": "6c58c6a62958e64e6a26bf9c", -"bigquery": "204206d1d1eecf007966cc5b", -"databricks": "6c58c6a62958e64e6a26bf9c", +"None": "9572f907cb1c76265b3b608f", +"bigquery": "9572f907cb1c76265b3b608f", +"databricks": "9572f907cb1c76265b3b608f", "duckdb": "6c58c6a62958e64e6a26bf9c", -"generic": "6c58c6a62958e64e6a26bf9c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c58c6a62958e64e6a26bf9c", -"postgres": "571886088d0423ed1a0f1696", -"postgresql": "571886088d0423ed1a0f1696", +"generic": "9572f907cb1c76265b3b608f", +"motherduck": "6c58c6a62958e64e6a26bf9c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9572f907cb1c76265b3b608f", +"postgresql": "9572f907cb1c76265b3b608f", "snowflake": "6c58c6a62958e64e6a26bf9c", -"tsql": "919b7ec6a7b49d8527b784cd" +"tsql": "9572f907cb1c76265b3b608f" } ], [ @@ -16107,8 +16107,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -16124,8 +16124,8 @@ "databricks": "42a76d5ff05d0f91911ff368", "duckdb": "42a76d5ff05d0f91911ff368", "generic": "42a76d5ff05d0f91911ff368", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "42a76d5ff05d0f91911ff368", +"motherduck": "42a76d5ff05d0f91911ff368", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "42a76d5ff05d0f91911ff368", "postgresql": "42a76d5ff05d0f91911ff368", "snowflake": "42a76d5ff05d0f91911ff368", @@ -16141,8 +16141,8 @@ "databricks": "251aba3fef503ce64556c701", "duckdb": "251aba3fef503ce64556c701", "generic": "251aba3fef503ce64556c701", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "251aba3fef503ce64556c701", +"motherduck": "251aba3fef503ce64556c701", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "251aba3fef503ce64556c701", "postgresql": "251aba3fef503ce64556c701", "snowflake": "c50a316d091c821866e4bfba", @@ -16154,12 +16154,12 @@ { "DuckDB": "5d25d5e13f81700741695ed4", "None": "5d25d5e13f81700741695ed4", -"bigquery": "23ee196b7bd6039855a1460f", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "5d25d5e13f81700741695ed4", "duckdb": "5d25d5e13f81700741695ed4", "generic": "5d25d5e13f81700741695ed4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d25d5e13f81700741695ed4", +"motherduck": "5d25d5e13f81700741695ed4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5d25d5e13f81700741695ed4", "postgresql": "5d25d5e13f81700741695ed4", "snowflake": "5d25d5e13f81700741695ed4", @@ -16175,8 +16175,8 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "1e75e5227bea0ae294ac7af1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19bdd92ea0cc5fb028657510", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "19bdd92ea0cc5fb028657510", "postgresql": "19bdd92ea0cc5fb028657510", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -16192,8 +16192,8 @@ "databricks": "268b9b7c7862c9de6569286a", "duckdb": "268b9b7c7862c9de6569286a", "generic": "268b9b7c7862c9de6569286a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "268b9b7c7862c9de6569286a", +"motherduck": "268b9b7c7862c9de6569286a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "268b9b7c7862c9de6569286a", "postgresql": "268b9b7c7862c9de6569286a", "snowflake": "268b9b7c7862c9de6569286a", @@ -16209,8 +16209,8 @@ "databricks": "da33de41a707d0e067e415fd", "duckdb": "da33de41a707d0e067e415fd", "generic": "da33de41a707d0e067e415fd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "da33de41a707d0e067e415fd", +"motherduck": "da33de41a707d0e067e415fd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "da33de41a707d0e067e415fd", "postgresql": "da33de41a707d0e067e415fd", "snowflake": "da33de41a707d0e067e415fd", @@ -16226,8 +16226,8 @@ "databricks": "7c8df74df226e73b459bfdba", "duckdb": "7c8df74df226e73b459bfdba", "generic": "7c8df74df226e73b459bfdba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7c8df74df226e73b459bfdba", +"motherduck": "7c8df74df226e73b459bfdba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7c8df74df226e73b459bfdba", "postgresql": "7c8df74df226e73b459bfdba", "snowflake": "7c8df74df226e73b459bfdba", @@ -16243,8 +16243,8 @@ "databricks": "ebb346128c80cb653e9694c8", "duckdb": "ebb346128c80cb653e9694c8", "generic": "ebb346128c80cb653e9694c8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebb346128c80cb653e9694c8", +"motherduck": "ebb346128c80cb653e9694c8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebb346128c80cb653e9694c8", "postgresql": "ebb346128c80cb653e9694c8", "snowflake": "ebb346128c80cb653e9694c8", @@ -16255,17 +16255,17 @@ "type", { "DuckDB": "9f4b51f000ffbe30f6b7d826", -"None": "bacfe825b19ef52bc792ab22", +"None": "00714a615c9e7a090fb122c5", "bigquery": "00714a615c9e7a090fb122c5", "databricks": "00714a615c9e7a090fb122c5", "duckdb": "9f4b51f000ffbe30f6b7d826", -"generic": "bacfe825b19ef52bc792ab22", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "00714a615c9e7a090fb122c5", -"postgres": "bacfe825b19ef52bc792ab22", -"postgresql": "bacfe825b19ef52bc792ab22", +"generic": "00714a615c9e7a090fb122c5", +"motherduck": "9f4b51f000ffbe30f6b7d826", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "30d01707c0b130f64a4d8414", +"postgresql": "30d01707c0b130f64a4d8414", "snowflake": "bacfe825b19ef52bc792ab22", -"tsql": "bacfe825b19ef52bc792ab22" +"tsql": "00714a615c9e7a090fb122c5" } ], [ @@ -16277,8 +16277,8 @@ "databricks": "f85dfff687194a44f32eeb15", "duckdb": "f85dfff687194a44f32eeb15", "generic": "f85dfff687194a44f32eeb15", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f85dfff687194a44f32eeb15", +"motherduck": "f85dfff687194a44f32eeb15", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f85dfff687194a44f32eeb15", "postgresql": "f85dfff687194a44f32eeb15", "snowflake": "f85dfff687194a44f32eeb15", @@ -16294,8 +16294,8 @@ "databricks": "24b677b214ecdacdb007642e", "duckdb": "24b677b214ecdacdb007642e", "generic": "24b677b214ecdacdb007642e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "24b677b214ecdacdb007642e", +"motherduck": "24b677b214ecdacdb007642e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "24b677b214ecdacdb007642e", "postgresql": "24b677b214ecdacdb007642e", "snowflake": "24b677b214ecdacdb007642e", @@ -16311,8 +16311,8 @@ "databricks": "4c2128e6078118fd0d3856fa", "duckdb": "4c2128e6078118fd0d3856fa", "generic": "4c2128e6078118fd0d3856fa", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4c2128e6078118fd0d3856fa", +"motherduck": "4c2128e6078118fd0d3856fa", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4c2128e6078118fd0d3856fa", "postgresql": "4c2128e6078118fd0d3856fa", "snowflake": "4c2128e6078118fd0d3856fa", @@ -16322,16 +16322,16 @@ [ "type", { -"DuckDB": "8698d724534891869075175e", -"None": "0017a88bb60ec3403c786ed8", +"DuckDB": "29525edc1ad146bad4372f59", +"None": "2795066c9a71fa3e3780c73b", "bigquery": "2795066c9a71fa3e3780c73b", -"databricks": "0017a88bb60ec3403c786ed8", -"duckdb": "8698d724534891869075175e", -"generic": "0017a88bb60ec3403c786ed8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "8698d724534891869075175e", -"postgresql": "8698d724534891869075175e", +"databricks": "2795066c9a71fa3e3780c73b", +"duckdb": "29525edc1ad146bad4372f59", +"generic": "2795066c9a71fa3e3780c73b", +"motherduck": "29525edc1ad146bad4372f59", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "29525edc1ad146bad4372f59", +"postgresql": "29525edc1ad146bad4372f59", "snowflake": "b3b752c645651b849e23d39a", "tsql": "d1dc9a140dbe2eb1874c6ad7" } @@ -16345,10 +16345,10 @@ "databricks": "b561884132dbe7e42b719110", "duckdb": "b561884132dbe7e42b719110", "generic": "b561884132dbe7e42b719110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b561884132dbe7e42b719110", -"postgres": "b561884132dbe7e42b719110", -"postgresql": "b561884132dbe7e42b719110", +"motherduck": "b561884132dbe7e42b719110", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5aa51d84ac5e6c7a9306f348", +"postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "b561884132dbe7e42b719110", "tsql": "b561884132dbe7e42b719110" } @@ -16362,8 +16362,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -16379,8 +16379,8 @@ "databricks": "e7b8de8bd235305d79e2b6b1", "duckdb": "e7b8de8bd235305d79e2b6b1", "generic": "e7b8de8bd235305d79e2b6b1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e7b8de8bd235305d79e2b6b1", +"motherduck": "e7b8de8bd235305d79e2b6b1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e7b8de8bd235305d79e2b6b1", "postgresql": "e7b8de8bd235305d79e2b6b1", "snowflake": "e7b8de8bd235305d79e2b6b1", @@ -16396,8 +16396,8 @@ "databricks": "9aff7fcc7d550e1a8d105471", "duckdb": "9aff7fcc7d550e1a8d105471", "generic": "9aff7fcc7d550e1a8d105471", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9aff7fcc7d550e1a8d105471", +"motherduck": "9aff7fcc7d550e1a8d105471", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9aff7fcc7d550e1a8d105471", "postgresql": "9aff7fcc7d550e1a8d105471", "snowflake": "9aff7fcc7d550e1a8d105471", @@ -16409,14 +16409,14 @@ { "DuckDB": "242bf50062e95bc8534ca887", "None": "242bf50062e95bc8534ca887", -"bigquery": "242bf50062e95bc8534ca887", +"bigquery": "67d251c042daee0bb2bf7351", "databricks": "242bf50062e95bc8534ca887", "duckdb": "242bf50062e95bc8534ca887", "generic": "242bf50062e95bc8534ca887", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "242bf50062e95bc8534ca887", -"postgres": "242bf50062e95bc8534ca887", -"postgresql": "242bf50062e95bc8534ca887", +"motherduck": "242bf50062e95bc8534ca887", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3f86c2b62e6298676c7001fd", +"postgresql": "3f86c2b62e6298676c7001fd", "snowflake": "242bf50062e95bc8534ca887", "tsql": "242bf50062e95bc8534ca887" } @@ -16430,10 +16430,10 @@ "databricks": "5d25d5e13f81700741695ed4", "duckdb": "5d25d5e13f81700741695ed4", "generic": "5d25d5e13f81700741695ed4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d25d5e13f81700741695ed4", -"postgres": "5d25d5e13f81700741695ed4", -"postgresql": "5d25d5e13f81700741695ed4", +"motherduck": "5d25d5e13f81700741695ed4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "62131fb5b065f5de2e74a0f1", +"postgresql": "62131fb5b065f5de2e74a0f1", "snowflake": "5d25d5e13f81700741695ed4", "tsql": "5d25d5e13f81700741695ed4" } @@ -16442,33 +16442,33 @@ "type", { "DuckDB": "13f1401e7cd410600a4c9485", -"None": "13f1401e7cd410600a4c9485", -"bigquery": "74a30f6aa9def0b58afc616c", -"databricks": "13f1401e7cd410600a4c9485", +"None": "75c45736873ac5c99a62bc20", +"bigquery": "a686bb6db17ab079cfc79224", +"databricks": "75c45736873ac5c99a62bc20", "duckdb": "13f1401e7cd410600a4c9485", -"generic": "13f1401e7cd410600a4c9485", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "13f1401e7cd410600a4c9485", +"generic": "75c45736873ac5c99a62bc20", +"motherduck": "13f1401e7cd410600a4c9485", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "13f1401e7cd410600a4c9485", "postgresql": "13f1401e7cd410600a4c9485", "snowflake": "9b5f44707b5f4764b82741be", -"tsql": "13f1401e7cd410600a4c9485" +"tsql": "75c45736873ac5c99a62bc20" } ], [ "type", { -"DuckDB": "6f851103102e7b986535376f", -"None": "6f851103102e7b986535376f", -"bigquery": "58b7e0908df666938398205f", -"databricks": "6f851103102e7b986535376f", -"duckdb": "6f851103102e7b986535376f", -"generic": "6f851103102e7b986535376f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1a853242fb56557e2865a86a", -"postgres": "6f851103102e7b986535376f", -"postgresql": "6f851103102e7b986535376f", -"snowflake": "87800133cac38d9119180c0a", +"DuckDB": "bf0a539a5f35525b6b4067c5", +"None": "8e2423c700938b33a6fea361", +"bigquery": "126d23e6f3408f484fe7bd92", +"databricks": "8e2423c700938b33a6fea361", +"duckdb": "bf0a539a5f35525b6b4067c5", +"generic": "8e2423c700938b33a6fea361", +"motherduck": "bf0a539a5f35525b6b4067c5", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "fac7e3f22dda1f3edd9dee28", +"postgresql": "fac7e3f22dda1f3edd9dee28", +"snowflake": "fe64d523696db51fa15d432e", "tsql": "0e9ef5373e5d52970e8e1656" } ], @@ -16481,8 +16481,8 @@ "databricks": "15be07c71f6871ae037caae3", "duckdb": "15be07c71f6871ae037caae3", "generic": "15be07c71f6871ae037caae3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "15be07c71f6871ae037caae3", +"motherduck": "15be07c71f6871ae037caae3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "15be07c71f6871ae037caae3", "postgresql": "15be07c71f6871ae037caae3", "snowflake": "15be07c71f6871ae037caae3", @@ -16498,8 +16498,8 @@ "databricks": "b210f8eb26c37b422f786c6b", "duckdb": "b210f8eb26c37b422f786c6b", "generic": "b210f8eb26c37b422f786c6b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b210f8eb26c37b422f786c6b", +"motherduck": "b210f8eb26c37b422f786c6b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b210f8eb26c37b422f786c6b", "postgresql": "b210f8eb26c37b422f786c6b", "snowflake": "b210f8eb26c37b422f786c6b", @@ -16515,8 +16515,8 @@ "databricks": "3d23f811a03db519b598c815", "duckdb": "3d23f811a03db519b598c815", "generic": "3d23f811a03db519b598c815", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3d23f811a03db519b598c815", +"motherduck": "3d23f811a03db519b598c815", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3d23f811a03db519b598c815", "postgresql": "3d23f811a03db519b598c815", "snowflake": "3d23f811a03db519b598c815", @@ -16532,8 +16532,8 @@ "databricks": "fa55698f69d154f89214f351", "duckdb": "fa55698f69d154f89214f351", "generic": "fa55698f69d154f89214f351", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fa55698f69d154f89214f351", +"motherduck": "fa55698f69d154f89214f351", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fa55698f69d154f89214f351", "postgresql": "fa55698f69d154f89214f351", "snowflake": "fa55698f69d154f89214f351", @@ -16549,8 +16549,8 @@ "databricks": "3009be83c84cdfc92bbb075e", "duckdb": "3009be83c84cdfc92bbb075e", "generic": "3009be83c84cdfc92bbb075e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3009be83c84cdfc92bbb075e", +"motherduck": "3009be83c84cdfc92bbb075e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3009be83c84cdfc92bbb075e", "postgresql": "3009be83c84cdfc92bbb075e", "snowflake": "3009be83c84cdfc92bbb075e", @@ -16566,10 +16566,10 @@ "databricks": "5d25d5e13f81700741695ed4", "duckdb": "5d25d5e13f81700741695ed4", "generic": "5d25d5e13f81700741695ed4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5d25d5e13f81700741695ed4", -"postgres": "5d25d5e13f81700741695ed4", -"postgresql": "5d25d5e13f81700741695ed4", +"motherduck": "5d25d5e13f81700741695ed4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "62131fb5b065f5de2e74a0f1", +"postgresql": "62131fb5b065f5de2e74a0f1", "snowflake": "5d25d5e13f81700741695ed4", "tsql": "5d25d5e13f81700741695ed4" } @@ -16583,8 +16583,8 @@ "databricks": "9d6807d797be08f8376a5a19", "duckdb": "9d6807d797be08f8376a5a19", "generic": "9d6807d797be08f8376a5a19", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9d6807d797be08f8376a5a19", +"motherduck": "9d6807d797be08f8376a5a19", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9d6807d797be08f8376a5a19", "postgresql": "9d6807d797be08f8376a5a19", "snowflake": "9d6807d797be08f8376a5a19", @@ -16600,8 +16600,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -16617,8 +16617,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -16630,14 +16630,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -16647,12 +16647,12 @@ { "DuckDB": "100c78a43fb3cbda50787a10", "None": "100c78a43fb3cbda50787a10", -"bigquery": "100c78a43fb3cbda50787a10", +"bigquery": "8d325bf2397f80882c281b76", "databricks": "100c78a43fb3cbda50787a10", "duckdb": "100c78a43fb3cbda50787a10", "generic": "100c78a43fb3cbda50787a10", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "100c78a43fb3cbda50787a10", +"motherduck": "100c78a43fb3cbda50787a10", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "100c78a43fb3cbda50787a10", "postgresql": "100c78a43fb3cbda50787a10", "snowflake": "100c78a43fb3cbda50787a10", @@ -16664,14 +16664,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -16681,14 +16681,14 @@ { "DuckDB": "624eb95d280fa0653ec73f7f", "None": "624eb95d280fa0653ec73f7f", -"bigquery": "624eb95d280fa0653ec73f7f", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "624eb95d280fa0653ec73f7f", "duckdb": "624eb95d280fa0653ec73f7f", "generic": "624eb95d280fa0653ec73f7f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "624eb95d280fa0653ec73f7f", -"postgres": "624eb95d280fa0653ec73f7f", -"postgresql": "624eb95d280fa0653ec73f7f", +"motherduck": "624eb95d280fa0653ec73f7f", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9dd376ce83bd3444e52fdb88", +"postgresql": "9dd376ce83bd3444e52fdb88", "snowflake": "624eb95d280fa0653ec73f7f", "tsql": "624eb95d280fa0653ec73f7f" } @@ -16698,14 +16698,14 @@ { "DuckDB": "6b04f574865e71733e09ba1d", "None": "6b04f574865e71733e09ba1d", -"bigquery": "6b04f574865e71733e09ba1d", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "6b04f574865e71733e09ba1d", "duckdb": "6b04f574865e71733e09ba1d", "generic": "6b04f574865e71733e09ba1d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6b04f574865e71733e09ba1d", -"postgres": "6b04f574865e71733e09ba1d", -"postgresql": "6b04f574865e71733e09ba1d", +"motherduck": "6b04f574865e71733e09ba1d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e4d1b966e983269b60041cc7", +"postgresql": "e4d1b966e983269b60041cc7", "snowflake": "6b04f574865e71733e09ba1d", "tsql": "6b04f574865e71733e09ba1d" } @@ -16719,8 +16719,8 @@ "databricks": "8a3f094f18fb4047f0febf59", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "8a3f094f18fb4047f0febf59", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8a3f094f18fb4047f0febf59", "postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "850deea990b52b82b36a9848", @@ -16736,8 +16736,8 @@ "databricks": "5aa51d84ac5e6c7a9306f348", "duckdb": "5aa51d84ac5e6c7a9306f348", "generic": "5aa51d84ac5e6c7a9306f348", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5aa51d84ac5e6c7a9306f348", +"motherduck": "5aa51d84ac5e6c7a9306f348", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5aa51d84ac5e6c7a9306f348", "postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "5aa51d84ac5e6c7a9306f348", @@ -16753,8 +16753,8 @@ "databricks": "07f8200cee37aa0f6990da3d", "duckdb": "07f8200cee37aa0f6990da3d", "generic": "07f8200cee37aa0f6990da3d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "07f8200cee37aa0f6990da3d", +"motherduck": "07f8200cee37aa0f6990da3d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "07f8200cee37aa0f6990da3d", "postgresql": "07f8200cee37aa0f6990da3d", "snowflake": "07f8200cee37aa0f6990da3d", @@ -16770,8 +16770,8 @@ "databricks": "ab5ad6180652b3b00d1f5b01", "duckdb": "ab5ad6180652b3b00d1f5b01", "generic": "ab5ad6180652b3b00d1f5b01", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ab5ad6180652b3b00d1f5b01", +"motherduck": "ab5ad6180652b3b00d1f5b01", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ab5ad6180652b3b00d1f5b01", "postgresql": "ab5ad6180652b3b00d1f5b01", "snowflake": "f43dac38f34a1c0618a3f812", @@ -16787,8 +16787,8 @@ "databricks": "47a5c4cbcdc5fda84d74a947", "duckdb": "47a5c4cbcdc5fda84d74a947", "generic": "47a5c4cbcdc5fda84d74a947", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "47a5c4cbcdc5fda84d74a947", +"motherduck": "47a5c4cbcdc5fda84d74a947", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "47a5c4cbcdc5fda84d74a947", "postgresql": "47a5c4cbcdc5fda84d74a947", "snowflake": "47a5c4cbcdc5fda84d74a947", @@ -16804,8 +16804,8 @@ "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e46d4be44ab9e500e9190d26", "postgresql": "e46d4be44ab9e500e9190d26", "snowflake": "e46d4be44ab9e500e9190d26", @@ -16821,10 +16821,10 @@ "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "b0ce99394388f977f67fd1df", +"postgresql": "b0ce99394388f977f67fd1df", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -16834,14 +16834,14 @@ { "DuckDB": "de89632e277dbc8c97115419", "None": "de89632e277dbc8c97115419", -"bigquery": "de89632e277dbc8c97115419", +"bigquery": "5abf4ec799a2ec32fb10da7e", "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -16855,8 +16855,8 @@ "databricks": "4fb572024031cb7631777be1", "duckdb": "792f7d3389f076f50c713946", "generic": "792f7d3389f076f50c713946", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "792f7d3389f076f50c713946", +"motherduck": "792f7d3389f076f50c713946", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "792f7d3389f076f50c713946", "postgresql": "792f7d3389f076f50c713946", "snowflake": "792f7d3389f076f50c713946", @@ -16868,12 +16868,12 @@ { "DuckDB": "aae2b1fe6f2d9807ecde412b", "None": "aae2b1fe6f2d9807ecde412b", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "aae2b1fe6f2d9807ecde412b", "duckdb": "aae2b1fe6f2d9807ecde412b", "generic": "aae2b1fe6f2d9807ecde412b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aae2b1fe6f2d9807ecde412b", +"motherduck": "aae2b1fe6f2d9807ecde412b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "aae2b1fe6f2d9807ecde412b", "postgresql": "aae2b1fe6f2d9807ecde412b", "snowflake": "aae2b1fe6f2d9807ecde412b", @@ -16884,17 +16884,17 @@ "type", { "DuckDB": "16adcdd909f51e3f33d7cdde", -"None": "1f3277ab2fff19e327e21fe0", -"bigquery": "1f3277ab2fff19e327e21fe0", -"databricks": "1f3277ab2fff19e327e21fe0", +"None": "ac92c18bc03647c2ff622e35", +"bigquery": "ac92c18bc03647c2ff622e35", +"databricks": "ac92c18bc03647c2ff622e35", "duckdb": "16adcdd909f51e3f33d7cdde", -"generic": "1f3277ab2fff19e327e21fe0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "de3f085b785f38a4bda19034", -"postgresql": "de3f085b785f38a4bda19034", +"generic": "ac92c18bc03647c2ff622e35", +"motherduck": "16adcdd909f51e3f33d7cdde", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ac92c18bc03647c2ff622e35", +"postgresql": "ac92c18bc03647c2ff622e35", "snowflake": "42ed29994060215ec30494f1", -"tsql": "d1dc9a140dbe2eb1874c6ad7" +"tsql": "ac92c18bc03647c2ff622e35" } ], [ @@ -16906,8 +16906,8 @@ "databricks": "690b44350cdb6852c9bc71a3", "duckdb": "690b44350cdb6852c9bc71a3", "generic": "690b44350cdb6852c9bc71a3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "690b44350cdb6852c9bc71a3", +"motherduck": "690b44350cdb6852c9bc71a3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "690b44350cdb6852c9bc71a3", "postgresql": "690b44350cdb6852c9bc71a3", "snowflake": "690b44350cdb6852c9bc71a3", @@ -16919,14 +16919,14 @@ { "DuckDB": "3a7ffeb8f81df6ccd57f3689", "None": "3a7ffeb8f81df6ccd57f3689", -"bigquery": "3a7ffeb8f81df6ccd57f3689", +"bigquery": "67d251c042daee0bb2bf7351", "databricks": "3a7ffeb8f81df6ccd57f3689", "duckdb": "3a7ffeb8f81df6ccd57f3689", "generic": "3a7ffeb8f81df6ccd57f3689", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3a7ffeb8f81df6ccd57f3689", -"postgres": "3a7ffeb8f81df6ccd57f3689", -"postgresql": "3a7ffeb8f81df6ccd57f3689", +"motherduck": "3a7ffeb8f81df6ccd57f3689", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "062e51ec86ccd542eb78500d", +"postgresql": "062e51ec86ccd542eb78500d", "snowflake": "3a7ffeb8f81df6ccd57f3689", "tsql": "3a7ffeb8f81df6ccd57f3689" } @@ -16940,8 +16940,8 @@ "databricks": "c752fd9fe2ad3b86b8b899da", "duckdb": "c752fd9fe2ad3b86b8b899da", "generic": "c752fd9fe2ad3b86b8b899da", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c752fd9fe2ad3b86b8b899da", +"motherduck": "c752fd9fe2ad3b86b8b899da", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e998cd8f0f74af0526b75ff0", "postgresql": "e998cd8f0f74af0526b75ff0", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -16957,8 +16957,8 @@ "databricks": "01d51e9454e607e1bab153ef", "duckdb": "01d51e9454e607e1bab153ef", "generic": "01d51e9454e607e1bab153ef", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "01d51e9454e607e1bab153ef", +"motherduck": "01d51e9454e607e1bab153ef", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "01d51e9454e607e1bab153ef", "postgresql": "01d51e9454e607e1bab153ef", "snowflake": "01d51e9454e607e1bab153ef", @@ -16974,8 +16974,8 @@ "databricks": "802f1c1fcb97ddd5679172d2", "duckdb": "802f1c1fcb97ddd5679172d2", "generic": "802f1c1fcb97ddd5679172d2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "802f1c1fcb97ddd5679172d2", +"motherduck": "802f1c1fcb97ddd5679172d2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "802f1c1fcb97ddd5679172d2", "postgresql": "802f1c1fcb97ddd5679172d2", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -16991,10 +16991,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -17008,8 +17008,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -17025,8 +17025,8 @@ "databricks": "fe0bedb7dda0e9247a51fdee", "duckdb": "fe0bedb7dda0e9247a51fdee", "generic": "fe0bedb7dda0e9247a51fdee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe0bedb7dda0e9247a51fdee", +"motherduck": "fe0bedb7dda0e9247a51fdee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fe0bedb7dda0e9247a51fdee", "postgresql": "fe0bedb7dda0e9247a51fdee", "snowflake": "fe0bedb7dda0e9247a51fdee", @@ -17042,8 +17042,8 @@ "databricks": "e1250582e271934cbcb2a788", "duckdb": "e1250582e271934cbcb2a788", "generic": "e1250582e271934cbcb2a788", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e1250582e271934cbcb2a788", +"motherduck": "e1250582e271934cbcb2a788", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e1250582e271934cbcb2a788", "postgresql": "e1250582e271934cbcb2a788", "snowflake": "e1250582e271934cbcb2a788", @@ -17055,14 +17055,14 @@ { "DuckDB": "dbf9ebbc7016f5ac5df2817e", "None": "dbf9ebbc7016f5ac5df2817e", -"bigquery": "dbf9ebbc7016f5ac5df2817e", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "dbf9ebbc7016f5ac5df2817e", "duckdb": "dbf9ebbc7016f5ac5df2817e", "generic": "dbf9ebbc7016f5ac5df2817e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "dbf9ebbc7016f5ac5df2817e", -"postgres": "dbf9ebbc7016f5ac5df2817e", -"postgresql": "dbf9ebbc7016f5ac5df2817e", +"motherduck": "dbf9ebbc7016f5ac5df2817e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "4cccf86e62d627a7a8b57726", +"postgresql": "4cccf86e62d627a7a8b57726", "snowflake": "dbf9ebbc7016f5ac5df2817e", "tsql": "dbf9ebbc7016f5ac5df2817e" } @@ -17072,14 +17072,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -17093,8 +17093,8 @@ "databricks": "1bdf5908ca249b2331a0427c", "duckdb": "1bdf5908ca249b2331a0427c", "generic": "1bdf5908ca249b2331a0427c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1bdf5908ca249b2331a0427c", +"motherduck": "1bdf5908ca249b2331a0427c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1bdf5908ca249b2331a0427c", "postgresql": "1bdf5908ca249b2331a0427c", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -17110,8 +17110,8 @@ "databricks": "6bd27be6a47ef34ec1defbad", "duckdb": "b0791f9f270e764eeeb6fb8e", "generic": "c7c38fdeaeb7858a44976f1d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c7c38fdeaeb7858a44976f1d", +"motherduck": "b0791f9f270e764eeeb6fb8e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4d7604d41e3585ec187dec82", "postgresql": "4d7604d41e3585ec187dec82", "snowflake": "c7c38fdeaeb7858a44976f1d", @@ -17127,8 +17127,8 @@ "databricks": "0b9d9879e289ea9a6a3e3e70", "duckdb": "0b9d9879e289ea9a6a3e3e70", "generic": "0b9d9879e289ea9a6a3e3e70", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0b9d9879e289ea9a6a3e3e70", +"motherduck": "0b9d9879e289ea9a6a3e3e70", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0b9d9879e289ea9a6a3e3e70", "postgresql": "0b9d9879e289ea9a6a3e3e70", "snowflake": "0b9d9879e289ea9a6a3e3e70", @@ -17144,8 +17144,8 @@ "databricks": "ba0da7ef018b990fcc83cba1", "duckdb": "ba0da7ef018b990fcc83cba1", "generic": "ba0da7ef018b990fcc83cba1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ba0da7ef018b990fcc83cba1", +"motherduck": "ba0da7ef018b990fcc83cba1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ba0da7ef018b990fcc83cba1", "postgresql": "ba0da7ef018b990fcc83cba1", "snowflake": "ba0da7ef018b990fcc83cba1", @@ -17155,33 +17155,33 @@ [ "type", { -"DuckDB": "51b0e597909858f7f7aa4571", -"None": "51b0e597909858f7f7aa4571", +"DuckDB": "9efea5795b256d49cab6a366", +"None": "9efea5795b256d49cab6a366", "bigquery": "deb9d53b04b7825e460d826a", -"databricks": "846f4ee64c34aab0cdabb9a0", -"duckdb": "51b0e597909858f7f7aa4571", -"generic": "51b0e597909858f7f7aa4571", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "51b0e597909858f7f7aa4571", -"postgres": "51b0e597909858f7f7aa4571", -"postgresql": "51b0e597909858f7f7aa4571", +"databricks": "d0f04a0ad4aff66d31330f7a", +"duckdb": "9efea5795b256d49cab6a366", +"generic": "9efea5795b256d49cab6a366", +"motherduck": "9efea5795b256d49cab6a366", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9efea5795b256d49cab6a366", +"postgresql": "9efea5795b256d49cab6a366", "snowflake": "50d14e3a5691e6cb8689aa29", -"tsql": "51b0e597909858f7f7aa4571" +"tsql": "9efea5795b256d49cab6a366" } ], [ "type", { -"DuckDB": "8698d724534891869075175e", -"None": "0017a88bb60ec3403c786ed8", +"DuckDB": "29525edc1ad146bad4372f59", +"None": "2795066c9a71fa3e3780c73b", "bigquery": "2795066c9a71fa3e3780c73b", -"databricks": "0017a88bb60ec3403c786ed8", -"duckdb": "8698d724534891869075175e", -"generic": "0017a88bb60ec3403c786ed8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "8698d724534891869075175e", -"postgresql": "8698d724534891869075175e", +"databricks": "2795066c9a71fa3e3780c73b", +"duckdb": "29525edc1ad146bad4372f59", +"generic": "2795066c9a71fa3e3780c73b", +"motherduck": "29525edc1ad146bad4372f59", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "29525edc1ad146bad4372f59", +"postgresql": "29525edc1ad146bad4372f59", "snowflake": "b3b752c645651b849e23d39a", "tsql": "d1dc9a140dbe2eb1874c6ad7" } @@ -17191,14 +17191,14 @@ { "DuckDB": "881106a4a0d2de0ff7c56373", "None": "881106a4a0d2de0ff7c56373", -"bigquery": "881106a4a0d2de0ff7c56373", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "881106a4a0d2de0ff7c56373", "duckdb": "881106a4a0d2de0ff7c56373", "generic": "881106a4a0d2de0ff7c56373", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "881106a4a0d2de0ff7c56373", -"postgres": "881106a4a0d2de0ff7c56373", -"postgresql": "881106a4a0d2de0ff7c56373", +"motherduck": "881106a4a0d2de0ff7c56373", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "cf167ec395fc843602e3b1e0", +"postgresql": "cf167ec395fc843602e3b1e0", "snowflake": "881106a4a0d2de0ff7c56373", "tsql": "881106a4a0d2de0ff7c56373" } @@ -17212,10 +17212,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -17229,10 +17229,10 @@ "databricks": "013a8446f043affffcf194f8", "duckdb": "013a8446f043affffcf194f8", "generic": "013a8446f043affffcf194f8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "013a8446f043affffcf194f8", -"postgres": "013a8446f043affffcf194f8", -"postgresql": "013a8446f043affffcf194f8", +"motherduck": "013a8446f043affffcf194f8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "b0477b36767a62145aa9158c", +"postgresql": "b0477b36767a62145aa9158c", "snowflake": "97a20344d811fb77c7690863", "tsql": "013a8446f043affffcf194f8" } @@ -17246,10 +17246,10 @@ "databricks": "804fec6876d0b43935790142", "duckdb": "804fec6876d0b43935790142", "generic": "804fec6876d0b43935790142", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "804fec6876d0b43935790142", -"postgres": "804fec6876d0b43935790142", -"postgresql": "804fec6876d0b43935790142", +"motherduck": "804fec6876d0b43935790142", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "191fc59c754706512337edc1", +"postgresql": "191fc59c754706512337edc1", "snowflake": "804fec6876d0b43935790142", "tsql": "804fec6876d0b43935790142" } @@ -17263,8 +17263,8 @@ "databricks": "0dcd6a19b7dc6f6b6d4a5006", "duckdb": "0dcd6a19b7dc6f6b6d4a5006", "generic": "0dcd6a19b7dc6f6b6d4a5006", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0dcd6a19b7dc6f6b6d4a5006", +"motherduck": "0dcd6a19b7dc6f6b6d4a5006", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0dcd6a19b7dc6f6b6d4a5006", "postgresql": "0dcd6a19b7dc6f6b6d4a5006", "snowflake": "0dcd6a19b7dc6f6b6d4a5006", @@ -17280,8 +17280,8 @@ "databricks": "9d6807d797be08f8376a5a19", "duckdb": "9d6807d797be08f8376a5a19", "generic": "9d6807d797be08f8376a5a19", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9d6807d797be08f8376a5a19", +"motherduck": "9d6807d797be08f8376a5a19", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9d6807d797be08f8376a5a19", "postgresql": "9d6807d797be08f8376a5a19", "snowflake": "9d6807d797be08f8376a5a19", @@ -17297,8 +17297,8 @@ "databricks": "3915f3f73328f0838497b2d5", "duckdb": "3915f3f73328f0838497b2d5", "generic": "3915f3f73328f0838497b2d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3915f3f73328f0838497b2d5", +"motherduck": "3915f3f73328f0838497b2d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3915f3f73328f0838497b2d5", "postgresql": "3915f3f73328f0838497b2d5", "snowflake": "f43dac38f34a1c0618a3f812", @@ -17314,8 +17314,8 @@ "databricks": "0dcd6a19b7dc6f6b6d4a5006", "duckdb": "0dcd6a19b7dc6f6b6d4a5006", "generic": "0dcd6a19b7dc6f6b6d4a5006", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0dcd6a19b7dc6f6b6d4a5006", +"motherduck": "0dcd6a19b7dc6f6b6d4a5006", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0dcd6a19b7dc6f6b6d4a5006", "postgresql": "0dcd6a19b7dc6f6b6d4a5006", "snowflake": "0dcd6a19b7dc6f6b6d4a5006", @@ -17327,14 +17327,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -17348,8 +17348,8 @@ "databricks": "d03c5e5797a8cbc0c6a81112", "duckdb": "d03c5e5797a8cbc0c6a81112", "generic": "d03c5e5797a8cbc0c6a81112", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d03c5e5797a8cbc0c6a81112", +"motherduck": "d03c5e5797a8cbc0c6a81112", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d03c5e5797a8cbc0c6a81112", "postgresql": "d03c5e5797a8cbc0c6a81112", "snowflake": "d03c5e5797a8cbc0c6a81112", @@ -17365,8 +17365,8 @@ "databricks": "6cffd1617edd6454241ee732", "duckdb": "6cffd1617edd6454241ee732", "generic": "6cffd1617edd6454241ee732", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6cffd1617edd6454241ee732", +"motherduck": "6cffd1617edd6454241ee732", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6cffd1617edd6454241ee732", "postgresql": "6cffd1617edd6454241ee732", "snowflake": "6cffd1617edd6454241ee732", @@ -17382,8 +17382,8 @@ "databricks": "98d56a64e9a7ee905a58c95c", "duckdb": "815698ef0c2515c76f250086", "generic": "98d56a64e9a7ee905a58c95c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "815698ef0c2515c76f250086", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "815698ef0c2515c76f250086", "postgresql": "815698ef0c2515c76f250086", "snowflake": "822641f83fbdcddae47b409f", @@ -17399,8 +17399,8 @@ "databricks": "1275b5b0c52f69cf592c004b", "duckdb": "1275b5b0c52f69cf592c004b", "generic": "1275b5b0c52f69cf592c004b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1275b5b0c52f69cf592c004b", +"motherduck": "1275b5b0c52f69cf592c004b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1275b5b0c52f69cf592c004b", "postgresql": "1275b5b0c52f69cf592c004b", "snowflake": "1275b5b0c52f69cf592c004b", @@ -17416,8 +17416,8 @@ "databricks": "80d6c9c5f502ef25b9434309", "duckdb": "80d6c9c5f502ef25b9434309", "generic": "80d6c9c5f502ef25b9434309", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "80d6c9c5f502ef25b9434309", +"motherduck": "80d6c9c5f502ef25b9434309", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "80d6c9c5f502ef25b9434309", "postgresql": "80d6c9c5f502ef25b9434309", "snowflake": "80d6c9c5f502ef25b9434309", @@ -17433,8 +17433,8 @@ "databricks": "42f6a9fe8a8cc486c2c77ae1", "duckdb": "42f6a9fe8a8cc486c2c77ae1", "generic": "42f6a9fe8a8cc486c2c77ae1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "42f6a9fe8a8cc486c2c77ae1", +"motherduck": "42f6a9fe8a8cc486c2c77ae1", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "42f6a9fe8a8cc486c2c77ae1", "postgresql": "42f6a9fe8a8cc486c2c77ae1", "snowflake": "42f6a9fe8a8cc486c2c77ae1", @@ -17450,8 +17450,8 @@ "databricks": "7894730ae1c06f4ea3920947", "duckdb": "7894730ae1c06f4ea3920947", "generic": "7894730ae1c06f4ea3920947", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7894730ae1c06f4ea3920947", +"motherduck": "7894730ae1c06f4ea3920947", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7894730ae1c06f4ea3920947", "postgresql": "7894730ae1c06f4ea3920947", "snowflake": "7894730ae1c06f4ea3920947", @@ -17461,18 +17461,18 @@ [ "type", { -"DuckDB": "f0c468b3e6d6df98b4358aff", -"None": "752ae7fc618de4a182e18bd3", -"bigquery": "752ae7fc618de4a182e18bd3", -"databricks": "aa5bc52ba6ea9e0a428084da", -"duckdb": "f0c468b3e6d6df98b4358aff", -"generic": "752ae7fc618de4a182e18bd3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "f0c468b3e6d6df98b4358aff", -"postgresql": "f0c468b3e6d6df98b4358aff", +"DuckDB": "a8f9cb9212d342eb9d2854d0", +"None": "3213ca7d92e0eff2f419451a", +"bigquery": "3213ca7d92e0eff2f419451a", +"databricks": "3213ca7d92e0eff2f419451a", +"duckdb": "a8f9cb9212d342eb9d2854d0", +"generic": "3213ca7d92e0eff2f419451a", +"motherduck": "a8f9cb9212d342eb9d2854d0", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3213ca7d92e0eff2f419451a", +"postgresql": "3213ca7d92e0eff2f419451a", "snowflake": "6dc518f5329c32ce13bfa506", -"tsql": "d1dc9a140dbe2eb1874c6ad7" +"tsql": "3213ca7d92e0eff2f419451a" } ], [ @@ -17480,14 +17480,14 @@ { "DuckDB": "9829fa9011a92bb968bb5996", "None": "9829fa9011a92bb968bb5996", -"bigquery": "9829fa9011a92bb968bb5996", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "9829fa9011a92bb968bb5996", "duckdb": "9829fa9011a92bb968bb5996", "generic": "9829fa9011a92bb968bb5996", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9829fa9011a92bb968bb5996", -"postgres": "9829fa9011a92bb968bb5996", -"postgresql": "9829fa9011a92bb968bb5996", +"motherduck": "9829fa9011a92bb968bb5996", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "4e937b76a5c3e503c1fd6e22", +"postgresql": "4e937b76a5c3e503c1fd6e22", "snowflake": "9829fa9011a92bb968bb5996", "tsql": "9829fa9011a92bb968bb5996" } @@ -17501,8 +17501,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -17518,8 +17518,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -17531,14 +17531,14 @@ { "DuckDB": "18db5afe2c1e80d1ee652b54", "None": "18db5afe2c1e80d1ee652b54", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "18db5afe2c1e80d1ee652b54", "duckdb": "18db5afe2c1e80d1ee652b54", "generic": "18db5afe2c1e80d1ee652b54", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "18db5afe2c1e80d1ee652b54", -"postgres": "18db5afe2c1e80d1ee652b54", -"postgresql": "18db5afe2c1e80d1ee652b54", +"motherduck": "18db5afe2c1e80d1ee652b54", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "47d64a5994d42a2b577166ea", +"postgresql": "47d64a5994d42a2b577166ea", "snowflake": "18db5afe2c1e80d1ee652b54", "tsql": "18db5afe2c1e80d1ee652b54" } @@ -17547,17 +17547,17 @@ "type", { "DuckDB": "c50a316d091c821866e4bfba", -"None": "c50a316d091c821866e4bfba", -"bigquery": "c50a316d091c821866e4bfba", -"databricks": "c50a316d091c821866e4bfba", +"None": "e6ffdece2977be55da73b59a", +"bigquery": "e6ffdece2977be55da73b59a", +"databricks": "e6ffdece2977be55da73b59a", "duckdb": "c50a316d091c821866e4bfba", -"generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"generic": "e6ffdece2977be55da73b59a", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", -"tsql": "c50a316d091c821866e4bfba" +"tsql": "e6ffdece2977be55da73b59a" } ], [ @@ -17569,10 +17569,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -17586,8 +17586,8 @@ "databricks": "8993aba016a0adde404608e3", "duckdb": "8993aba016a0adde404608e3", "generic": "8993aba016a0adde404608e3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8993aba016a0adde404608e3", +"motherduck": "8993aba016a0adde404608e3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8993aba016a0adde404608e3", "postgresql": "8993aba016a0adde404608e3", "snowflake": "8993aba016a0adde404608e3", @@ -17599,14 +17599,14 @@ { "DuckDB": "837168a49b84e7ed918ea148", "None": "837168a49b84e7ed918ea148", -"bigquery": "837168a49b84e7ed918ea148", +"bigquery": "67d251c042daee0bb2bf7351", "databricks": "837168a49b84e7ed918ea148", "duckdb": "837168a49b84e7ed918ea148", "generic": "837168a49b84e7ed918ea148", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "837168a49b84e7ed918ea148", -"postgres": "837168a49b84e7ed918ea148", -"postgresql": "837168a49b84e7ed918ea148", +"motherduck": "837168a49b84e7ed918ea148", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "c28e9468b9f7a7f4e67d5b30", +"postgresql": "c28e9468b9f7a7f4e67d5b30", "snowflake": "837168a49b84e7ed918ea148", "tsql": "837168a49b84e7ed918ea148" } @@ -17620,8 +17620,8 @@ "databricks": "3915f3f73328f0838497b2d5", "duckdb": "3915f3f73328f0838497b2d5", "generic": "3915f3f73328f0838497b2d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3915f3f73328f0838497b2d5", +"motherduck": "3915f3f73328f0838497b2d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3915f3f73328f0838497b2d5", "postgresql": "3915f3f73328f0838497b2d5", "snowflake": "f43dac38f34a1c0618a3f812", @@ -17637,8 +17637,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -17654,8 +17654,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -17667,14 +17667,14 @@ { "DuckDB": "08736485547ba339930697e9", "None": "08736485547ba339930697e9", -"bigquery": "08736485547ba339930697e9", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "08736485547ba339930697e9", "duckdb": "08736485547ba339930697e9", "generic": "08736485547ba339930697e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "08736485547ba339930697e9", -"postgres": "08736485547ba339930697e9", -"postgresql": "08736485547ba339930697e9", +"motherduck": "08736485547ba339930697e9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eecd452b4f5f3f4133d0bd0a", +"postgresql": "eecd452b4f5f3f4133d0bd0a", "snowflake": "08736485547ba339930697e9", "tsql": "08736485547ba339930697e9" } @@ -17688,8 +17688,8 @@ "databricks": "c6889f2965db73017be6f6e7", "duckdb": "c6889f2965db73017be6f6e7", "generic": "c6889f2965db73017be6f6e7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6889f2965db73017be6f6e7", +"motherduck": "c6889f2965db73017be6f6e7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6889f2965db73017be6f6e7", "postgresql": "c6889f2965db73017be6f6e7", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -17701,12 +17701,12 @@ { "DuckDB": "461923a0d34defd0c726d6e5", "None": "461923a0d34defd0c726d6e5", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "461923a0d34defd0c726d6e5", "duckdb": "461923a0d34defd0c726d6e5", "generic": "461923a0d34defd0c726d6e5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "461923a0d34defd0c726d6e5", +"motherduck": "461923a0d34defd0c726d6e5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "461923a0d34defd0c726d6e5", "postgresql": "461923a0d34defd0c726d6e5", "snowflake": "461923a0d34defd0c726d6e5", @@ -17718,14 +17718,14 @@ { "DuckDB": "624eb95d280fa0653ec73f7f", "None": "624eb95d280fa0653ec73f7f", -"bigquery": "624eb95d280fa0653ec73f7f", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "624eb95d280fa0653ec73f7f", "duckdb": "624eb95d280fa0653ec73f7f", "generic": "624eb95d280fa0653ec73f7f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "624eb95d280fa0653ec73f7f", -"postgres": "624eb95d280fa0653ec73f7f", -"postgresql": "624eb95d280fa0653ec73f7f", +"motherduck": "624eb95d280fa0653ec73f7f", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9dd376ce83bd3444e52fdb88", +"postgresql": "9dd376ce83bd3444e52fdb88", "snowflake": "624eb95d280fa0653ec73f7f", "tsql": "624eb95d280fa0653ec73f7f" } @@ -17734,17 +17734,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -17756,10 +17756,10 @@ "databricks": "bce60580ef3a1dc4ce569fff", "duckdb": "bce60580ef3a1dc4ce569fff", "generic": "bce60580ef3a1dc4ce569fff", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "bce60580ef3a1dc4ce569fff", -"postgres": "bce60580ef3a1dc4ce569fff", -"postgresql": "bce60580ef3a1dc4ce569fff", +"motherduck": "bce60580ef3a1dc4ce569fff", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eee236ea1427bdddbaf088ac", +"postgresql": "eee236ea1427bdddbaf088ac", "snowflake": "bce60580ef3a1dc4ce569fff", "tsql": "bce60580ef3a1dc4ce569fff" } @@ -17773,8 +17773,8 @@ "databricks": "a104f9b34b3d9d798095a6b4", "duckdb": "a104f9b34b3d9d798095a6b4", "generic": "a104f9b34b3d9d798095a6b4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a104f9b34b3d9d798095a6b4", +"motherduck": "a104f9b34b3d9d798095a6b4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a104f9b34b3d9d798095a6b4", "postgresql": "a104f9b34b3d9d798095a6b4", "snowflake": "a104f9b34b3d9d798095a6b4", @@ -17785,17 +17785,17 @@ "type", { "DuckDB": "858855737713d0cff353f8ac", -"None": "858855737713d0cff353f8ac", -"bigquery": "858855737713d0cff353f8ac", -"databricks": "858855737713d0cff353f8ac", +"None": "50b29536a9929d11dbcb949a", +"bigquery": "8b8d5f75ba6dec68b4cebc6b", +"databricks": "50b29536a9929d11dbcb949a", "duckdb": "858855737713d0cff353f8ac", -"generic": "858855737713d0cff353f8ac", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "858855737713d0cff353f8ac", -"postgres": "858855737713d0cff353f8ac", -"postgresql": "858855737713d0cff353f8ac", +"generic": "50b29536a9929d11dbcb949a", +"motherduck": "858855737713d0cff353f8ac", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "74a30f6aa9def0b58afc616c", +"postgresql": "74a30f6aa9def0b58afc616c", "snowflake": "858855737713d0cff353f8ac", -"tsql": "858855737713d0cff353f8ac" +"tsql": "50b29536a9929d11dbcb949a" } ], [ @@ -17803,12 +17803,12 @@ { "DuckDB": "62368fc15cefd5807807b209", "None": "62368fc15cefd5807807b209", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "62368fc15cefd5807807b209", "duckdb": "62368fc15cefd5807807b209", "generic": "62368fc15cefd5807807b209", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "62368fc15cefd5807807b209", +"motherduck": "62368fc15cefd5807807b209", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "62368fc15cefd5807807b209", "postgresql": "62368fc15cefd5807807b209", "snowflake": "62368fc15cefd5807807b209", @@ -17824,8 +17824,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -17841,8 +17841,8 @@ "databricks": "4ce8ae479c93f9ff48189fc3", "duckdb": "4ce8ae479c93f9ff48189fc3", "generic": "4ce8ae479c93f9ff48189fc3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4ce8ae479c93f9ff48189fc3", +"motherduck": "4ce8ae479c93f9ff48189fc3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4ce8ae479c93f9ff48189fc3", "postgresql": "4ce8ae479c93f9ff48189fc3", "snowflake": "4ce8ae479c93f9ff48189fc3", @@ -17858,8 +17858,8 @@ "databricks": "fb5907c56dd752ac5f1dbd95", "duckdb": "fb5907c56dd752ac5f1dbd95", "generic": "fb5907c56dd752ac5f1dbd95", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fb5907c56dd752ac5f1dbd95", +"motherduck": "fb5907c56dd752ac5f1dbd95", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fb5907c56dd752ac5f1dbd95", "postgresql": "fb5907c56dd752ac5f1dbd95", "snowflake": "fb5907c56dd752ac5f1dbd95", @@ -17875,8 +17875,8 @@ "databricks": "aab5b077409069695e7d847d", "duckdb": "aab5b077409069695e7d847d", "generic": "aab5b077409069695e7d847d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab5b077409069695e7d847d", +"motherduck": "aab5b077409069695e7d847d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "aab5b077409069695e7d847d", "postgresql": "aab5b077409069695e7d847d", "snowflake": "aab5b077409069695e7d847d", @@ -17887,17 +17887,17 @@ "type", { "DuckDB": "d81d8c19074af0e39239164d", -"None": "1fec266134381c760a254d16", -"bigquery": "1fec266134381c760a254d16", -"databricks": "1fec266134381c760a254d16", +"None": "a52676af0c6b750acc33f021", +"bigquery": "1e75e5227bea0ae294ac7af1", +"databricks": "a52676af0c6b750acc33f021", "duckdb": "d81d8c19074af0e39239164d", -"generic": "1fec266134381c760a254d16", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1fec266134381c760a254d16", -"postgres": "1fec266134381c760a254d16", -"postgresql": "1fec266134381c760a254d16", +"generic": "a52676af0c6b750acc33f021", +"motherduck": "d81d8c19074af0e39239164d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a52676af0c6b750acc33f021", +"postgresql": "a52676af0c6b750acc33f021", "snowflake": "1fec266134381c760a254d16", -"tsql": "1fec266134381c760a254d16" +"tsql": "a52676af0c6b750acc33f021" } ], [ @@ -17909,8 +17909,8 @@ "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "de89632e277dbc8c97115419", "postgresql": "de89632e277dbc8c97115419", "snowflake": "4b356542044f1267fcfc487a", @@ -17926,10 +17926,10 @@ "databricks": "b561884132dbe7e42b719110", "duckdb": "b561884132dbe7e42b719110", "generic": "b561884132dbe7e42b719110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b561884132dbe7e42b719110", -"postgres": "b561884132dbe7e42b719110", -"postgresql": "b561884132dbe7e42b719110", +"motherduck": "b561884132dbe7e42b719110", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5aa51d84ac5e6c7a9306f348", +"postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "b561884132dbe7e42b719110", "tsql": "b561884132dbe7e42b719110" } @@ -17943,8 +17943,8 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "111af35848fe500ec2ae54b2", "generic": "111af35848fe500ec2ae54b2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e3bc1b8bad22d8104417b00f", +"motherduck": "111af35848fe500ec2ae54b2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "111af35848fe500ec2ae54b2", "postgresql": "111af35848fe500ec2ae54b2", "snowflake": "e3bc1b8bad22d8104417b00f", @@ -17955,17 +17955,17 @@ "type", { "DuckDB": "a428302e4848ffe877284c84", -"None": "a428302e4848ffe877284c84", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "a428302e4848ffe877284c84", +"None": "c9b810639795a7bfab91b98d", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "c9b810639795a7bfab91b98d", "duckdb": "a428302e4848ffe877284c84", -"generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"generic": "c9b810639795a7bfab91b98d", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "a428302e4848ffe877284c84" +"tsql": "c9b810639795a7bfab91b98d" } ], [ @@ -17973,12 +17973,12 @@ { "DuckDB": "47d74d1b45fedd02ec465220", "None": "47d74d1b45fedd02ec465220", -"bigquery": "47d74d1b45fedd02ec465220", +"bigquery": "15362056f760cad102922b12", "databricks": "47d74d1b45fedd02ec465220", "duckdb": "47d74d1b45fedd02ec465220", "generic": "47d74d1b45fedd02ec465220", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "47d74d1b45fedd02ec465220", +"motherduck": "47d74d1b45fedd02ec465220", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "47d74d1b45fedd02ec465220", "postgresql": "47d74d1b45fedd02ec465220", "snowflake": "47d74d1b45fedd02ec465220", @@ -17994,8 +17994,8 @@ "databricks": "60a23b7dcae6c79f4de83068", "duckdb": "60a23b7dcae6c79f4de83068", "generic": "60a23b7dcae6c79f4de83068", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "60a23b7dcae6c79f4de83068", +"motherduck": "60a23b7dcae6c79f4de83068", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "60a23b7dcae6c79f4de83068", "postgresql": "60a23b7dcae6c79f4de83068", "snowflake": "60a23b7dcae6c79f4de83068", @@ -18006,17 +18006,17 @@ "type", { "DuckDB": "1879bc874141d9160106e020", -"None": "c513dcc8ed8dfd8935374a47", -"bigquery": "c513dcc8ed8dfd8935374a47", -"databricks": "c513dcc8ed8dfd8935374a47", +"None": "072b6126112a6217e028fc8f", +"bigquery": "072b6126112a6217e028fc8f", +"databricks": "072b6126112a6217e028fc8f", "duckdb": "1879bc874141d9160106e020", -"generic": "c513dcc8ed8dfd8935374a47", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c513dcc8ed8dfd8935374a47", +"generic": "072b6126112a6217e028fc8f", +"motherduck": "1879bc874141d9160106e020", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c513dcc8ed8dfd8935374a47", "postgresql": "c513dcc8ed8dfd8935374a47", "snowflake": "c513dcc8ed8dfd8935374a47", -"tsql": "c513dcc8ed8dfd8935374a47" +"tsql": "072b6126112a6217e028fc8f" } ], [ @@ -18028,10 +18028,10 @@ "databricks": "2705f19942a4194a72576911", "duckdb": "2705f19942a4194a72576911", "generic": "2705f19942a4194a72576911", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2705f19942a4194a72576911", -"postgres": "2705f19942a4194a72576911", -"postgresql": "2705f19942a4194a72576911", +"motherduck": "2705f19942a4194a72576911", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5226d7e2a62c7650a87d6e84", +"postgresql": "5226d7e2a62c7650a87d6e84", "snowflake": "2705f19942a4194a72576911", "tsql": "2705f19942a4194a72576911" } @@ -18045,8 +18045,8 @@ "databricks": "9b1399d4f1923837359745f8", "duckdb": "9b1399d4f1923837359745f8", "generic": "9b1399d4f1923837359745f8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9b1399d4f1923837359745f8", +"motherduck": "9b1399d4f1923837359745f8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9b1399d4f1923837359745f8", "postgresql": "9b1399d4f1923837359745f8", "snowflake": "9b1399d4f1923837359745f8", @@ -18056,16 +18056,16 @@ [ "type", { -"DuckDB": "c43574432afc90bcba6944b2", -"None": "7040afbb3a088baf55e328b2", -"bigquery": "ba611057434e43344935471b", -"databricks": "ba611057434e43344935471b", -"duckdb": "c43574432afc90bcba6944b2", -"generic": "7040afbb3a088baf55e328b2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "1b3243409566f14d81c11fff", -"postgresql": "1b3243409566f14d81c11fff", +"DuckDB": "83f3a2696c58aa8d709a227a", +"None": "3866c29c7e0df841d464b98c", +"bigquery": "3866c29c7e0df841d464b98c", +"databricks": "3866c29c7e0df841d464b98c", +"duckdb": "83f3a2696c58aa8d709a227a", +"generic": "3866c29c7e0df841d464b98c", +"motherduck": "83f3a2696c58aa8d709a227a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3866c29c7e0df841d464b98c", +"postgresql": "3866c29c7e0df841d464b98c", "snowflake": "06a9af03923de91e5e27860a", "tsql": "3866c29c7e0df841d464b98c" } @@ -18074,17 +18074,17 @@ "type", { "DuckDB": "d229e289e63364bf0d56e920", -"None": "28c3447161aa1c0a550659b8", -"bigquery": "28c3447161aa1c0a550659b8", -"databricks": "b8e50cd0369cf0810e7054be", +"None": "5b121b9b6ea0450c8d33ee34", +"bigquery": "ded028ebfb27c12284a8381a", +"databricks": "5b121b9b6ea0450c8d33ee34", "duckdb": "d229e289e63364bf0d56e920", -"generic": "28c3447161aa1c0a550659b8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "28c3447161aa1c0a550659b8", -"postgres": "28c3447161aa1c0a550659b8", -"postgresql": "28c3447161aa1c0a550659b8", +"generic": "5b121b9b6ea0450c8d33ee34", +"motherduck": "d229e289e63364bf0d56e920", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5b121b9b6ea0450c8d33ee34", +"postgresql": "5b121b9b6ea0450c8d33ee34", "snowflake": "d90e8915a295b2cd5e690bd1", -"tsql": "28c3447161aa1c0a550659b8" +"tsql": "5b121b9b6ea0450c8d33ee34" } ], [ @@ -18096,10 +18096,10 @@ "databricks": "a3acd7ba35e81a800f967bd3", "duckdb": "42d4a23d9a52e79d0c3458d3", "generic": "a3acd7ba35e81a800f967bd3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a3acd7ba35e81a800f967bd3", -"postgres": "a3acd7ba35e81a800f967bd3", -"postgresql": "a3acd7ba35e81a800f967bd3", +"motherduck": "42d4a23d9a52e79d0c3458d3", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "42d4a23d9a52e79d0c3458d3", +"postgresql": "42d4a23d9a52e79d0c3458d3", "snowflake": "a3acd7ba35e81a800f967bd3", "tsql": "a3acd7ba35e81a800f967bd3" } @@ -18113,10 +18113,10 @@ "databricks": "c6106f30f23f392e17eadef4", "duckdb": "c6106f30f23f392e17eadef4", "generic": "c6106f30f23f392e17eadef4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6106f30f23f392e17eadef4", -"postgres": "c6106f30f23f392e17eadef4", -"postgresql": "c6106f30f23f392e17eadef4", +"motherduck": "c6106f30f23f392e17eadef4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f43dac38f34a1c0618a3f812", +"postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "c6106f30f23f392e17eadef4", "tsql": "c6106f30f23f392e17eadef4" } @@ -18130,10 +18130,10 @@ "databricks": "804fec6876d0b43935790142", "duckdb": "804fec6876d0b43935790142", "generic": "804fec6876d0b43935790142", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "804fec6876d0b43935790142", -"postgres": "804fec6876d0b43935790142", -"postgresql": "804fec6876d0b43935790142", +"motherduck": "804fec6876d0b43935790142", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "191fc59c754706512337edc1", +"postgresql": "191fc59c754706512337edc1", "snowflake": "804fec6876d0b43935790142", "tsql": "804fec6876d0b43935790142" } @@ -18147,8 +18147,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -18164,10 +18164,10 @@ "databricks": "7b87db889221e05e13ec3845", "duckdb": "194c385aa00f52f45426748f", "generic": "7b87db889221e05e13ec3845", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7b87db889221e05e13ec3845", -"postgres": "7b87db889221e05e13ec3845", -"postgresql": "7b87db889221e05e13ec3845", +"motherduck": "194c385aa00f52f45426748f", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "07fffe8743dfd4e88e6b3f18", +"postgresql": "07fffe8743dfd4e88e6b3f18", "snowflake": "7b87db889221e05e13ec3845", "tsql": "7b87db889221e05e13ec3845" } @@ -18181,10 +18181,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -18198,12 +18198,12 @@ "databricks": "eb72e9a8e16bab9ee01146ee", "duckdb": "c69a366e715a81bca598d475", "generic": "c69a366e715a81bca598d475", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c69a366e715a81bca598d475", +"motherduck": "c69a366e715a81bca598d475", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c69a366e715a81bca598d475", "postgresql": "c69a366e715a81bca598d475", "snowflake": "f41d94b0bed9910074641da6", -"tsql": "c69a366e715a81bca598d475" +"tsql": "c036322107e1c935c7bc6edd" } ], [ @@ -18211,12 +18211,12 @@ { "DuckDB": "558da38ec4d9d5d6c72f60cf", "None": "558da38ec4d9d5d6c72f60cf", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "558da38ec4d9d5d6c72f60cf", "duckdb": "558da38ec4d9d5d6c72f60cf", "generic": "558da38ec4d9d5d6c72f60cf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "558da38ec4d9d5d6c72f60cf", +"motherduck": "558da38ec4d9d5d6c72f60cf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "558da38ec4d9d5d6c72f60cf", "postgresql": "558da38ec4d9d5d6c72f60cf", "snowflake": "558da38ec4d9d5d6c72f60cf", @@ -18232,8 +18232,8 @@ "databricks": "b210f8eb26c37b422f786c6b", "duckdb": "b210f8eb26c37b422f786c6b", "generic": "b210f8eb26c37b422f786c6b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b210f8eb26c37b422f786c6b", +"motherduck": "b210f8eb26c37b422f786c6b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b210f8eb26c37b422f786c6b", "postgresql": "b210f8eb26c37b422f786c6b", "snowflake": "b210f8eb26c37b422f786c6b", @@ -18249,10 +18249,10 @@ "databricks": "279ea7f6f6a3910de04b795b", "duckdb": "279ea7f6f6a3910de04b795b", "generic": "279ea7f6f6a3910de04b795b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "279ea7f6f6a3910de04b795b", -"postgres": "279ea7f6f6a3910de04b795b", -"postgresql": "279ea7f6f6a3910de04b795b", +"motherduck": "279ea7f6f6a3910de04b795b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "bc520aebd5872e40030ec7d9", +"postgresql": "bc520aebd5872e40030ec7d9", "snowflake": "279ea7f6f6a3910de04b795b", "tsql": "279ea7f6f6a3910de04b795b" } @@ -18263,11 +18263,11 @@ "DuckDB": "92e8caae709d951bb8ed59cb", "None": "92e8caae709d951bb8ed59cb", "bigquery": "92e8caae709d951bb8ed59cb", -"databricks": "1758ac00dad1bae84521b3fb", +"databricks": "92e8caae709d951bb8ed59cb", "duckdb": "92e8caae709d951bb8ed59cb", "generic": "92e8caae709d951bb8ed59cb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1758ac00dad1bae84521b3fb", +"motherduck": "92e8caae709d951bb8ed59cb", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "92e8caae709d951bb8ed59cb", "postgresql": "92e8caae709d951bb8ed59cb", "snowflake": "92e8caae709d951bb8ed59cb", @@ -18283,8 +18283,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -18300,10 +18300,10 @@ "databricks": "a686bb6db17ab079cfc79224", "duckdb": "a686bb6db17ab079cfc79224", "generic": "a686bb6db17ab079cfc79224", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a686bb6db17ab079cfc79224", -"postgres": "a686bb6db17ab079cfc79224", -"postgresql": "a686bb6db17ab079cfc79224", +"motherduck": "a686bb6db17ab079cfc79224", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "74a30f6aa9def0b58afc616c", +"postgresql": "74a30f6aa9def0b58afc616c", "snowflake": "1096c3c8687c8e8eb538ff74", "tsql": "a686bb6db17ab079cfc79224" } @@ -18317,10 +18317,10 @@ "databricks": "56f06885daf94b4fcc0a624b", "duckdb": "56f06885daf94b4fcc0a624b", "generic": "56f06885daf94b4fcc0a624b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "56f06885daf94b4fcc0a624b", -"postgres": "56f06885daf94b4fcc0a624b", -"postgresql": "56f06885daf94b4fcc0a624b", +"motherduck": "56f06885daf94b4fcc0a624b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "d8c1f10bbe9d46ecb6ee0bc7", +"postgresql": "d8c1f10bbe9d46ecb6ee0bc7", "snowflake": "56f06885daf94b4fcc0a624b", "tsql": "56f06885daf94b4fcc0a624b" } @@ -18334,8 +18334,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -18351,8 +18351,8 @@ "databricks": "0703bf71a54942bdaa28406e", "duckdb": "0703bf71a54942bdaa28406e", "generic": "0703bf71a54942bdaa28406e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0703bf71a54942bdaa28406e", +"motherduck": "0703bf71a54942bdaa28406e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0703bf71a54942bdaa28406e", "postgresql": "0703bf71a54942bdaa28406e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -18368,10 +18368,10 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "396b2ce32efb5365b393c230", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", -"postgres": "e57ac1541fb51b362cd5b470", -"postgresql": "e57ac1541fb51b362cd5b470", +"motherduck": "396b2ce32efb5365b393c230", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "396b2ce32efb5365b393c230", +"postgresql": "396b2ce32efb5365b393c230", "snowflake": "4b356542044f1267fcfc487a", "tsql": "e57ac1541fb51b362cd5b470" } @@ -18385,8 +18385,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "305aaf0b95cee629dd46380c", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "305aaf0b95cee629dd46380c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -18402,10 +18402,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -18419,10 +18419,10 @@ "databricks": "d2c97d221599d038d9875873", "duckdb": "f7fca17b74cc50ae3de8c826", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "f7fca17b74cc50ae3de8c826", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -18436,8 +18436,8 @@ "databricks": "d1dc9a140dbe2eb1874c6ad7", "duckdb": "d1dc9a140dbe2eb1874c6ad7", "generic": "d1dc9a140dbe2eb1874c6ad7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d1dc9a140dbe2eb1874c6ad7", +"motherduck": "d1dc9a140dbe2eb1874c6ad7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d1dc9a140dbe2eb1874c6ad7", "postgresql": "d1dc9a140dbe2eb1874c6ad7", "snowflake": "d1dc9a140dbe2eb1874c6ad7", @@ -18453,10 +18453,10 @@ "databricks": "4c78bdde0b2dfd77ab71c9e8", "duckdb": "4c78bdde0b2dfd77ab71c9e8", "generic": "4c78bdde0b2dfd77ab71c9e8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4c78bdde0b2dfd77ab71c9e8", -"postgres": "4c78bdde0b2dfd77ab71c9e8", -"postgresql": "4c78bdde0b2dfd77ab71c9e8", +"motherduck": "4c78bdde0b2dfd77ab71c9e8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e802515d969e770f686478b5", +"postgresql": "e802515d969e770f686478b5", "snowflake": "4c78bdde0b2dfd77ab71c9e8", "tsql": "4c78bdde0b2dfd77ab71c9e8" } @@ -18470,8 +18470,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -18487,8 +18487,8 @@ "databricks": "8a3f094f18fb4047f0febf59", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "8a3f094f18fb4047f0febf59", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8a3f094f18fb4047f0febf59", "postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "850deea990b52b82b36a9848", @@ -18499,17 +18499,17 @@ "type", { "DuckDB": "f46cf4b4e131aa122b5b33d6", -"None": "f46cf4b4e131aa122b5b33d6", -"bigquery": "f46cf4b4e131aa122b5b33d6", -"databricks": "f46cf4b4e131aa122b5b33d6", +"None": "f774d5e8feadbf11edaa26b1", +"bigquery": "9bafb08d41fd1c208b5deca4", +"databricks": "f774d5e8feadbf11edaa26b1", "duckdb": "f46cf4b4e131aa122b5b33d6", -"generic": "f46cf4b4e131aa122b5b33d6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f46cf4b4e131aa122b5b33d6", +"generic": "f774d5e8feadbf11edaa26b1", +"motherduck": "f46cf4b4e131aa122b5b33d6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f46cf4b4e131aa122b5b33d6", "postgresql": "f46cf4b4e131aa122b5b33d6", "snowflake": "f46cf4b4e131aa122b5b33d6", -"tsql": "f46cf4b4e131aa122b5b33d6" +"tsql": "f774d5e8feadbf11edaa26b1" } ], [ @@ -18521,8 +18521,8 @@ "databricks": "f43dac38f34a1c0618a3f812", "duckdb": "f43dac38f34a1c0618a3f812", "generic": "f43dac38f34a1c0618a3f812", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f43dac38f34a1c0618a3f812", +"motherduck": "f43dac38f34a1c0618a3f812", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f43dac38f34a1c0618a3f812", "postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "f43dac38f34a1c0618a3f812", @@ -18534,14 +18534,14 @@ { "DuckDB": "6eb49ceb88fcb2297831ca05", "None": "6eb49ceb88fcb2297831ca05", -"bigquery": "6eb49ceb88fcb2297831ca05", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "6eb49ceb88fcb2297831ca05", "duckdb": "6eb49ceb88fcb2297831ca05", "generic": "6eb49ceb88fcb2297831ca05", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6eb49ceb88fcb2297831ca05", -"postgres": "6eb49ceb88fcb2297831ca05", -"postgresql": "6eb49ceb88fcb2297831ca05", +"motherduck": "6eb49ceb88fcb2297831ca05", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "623e22ea8921c9e57a15475b", +"postgresql": "623e22ea8921c9e57a15475b", "snowflake": "6eb49ceb88fcb2297831ca05", "tsql": "6eb49ceb88fcb2297831ca05" } @@ -18555,8 +18555,8 @@ "databricks": "853b2c0ad6ea4565b1e301e8", "duckdb": "853b2c0ad6ea4565b1e301e8", "generic": "853b2c0ad6ea4565b1e301e8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "853b2c0ad6ea4565b1e301e8", +"motherduck": "853b2c0ad6ea4565b1e301e8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "853b2c0ad6ea4565b1e301e8", "postgresql": "853b2c0ad6ea4565b1e301e8", "snowflake": "853b2c0ad6ea4565b1e301e8", @@ -18572,10 +18572,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -18584,17 +18584,17 @@ "type", { "DuckDB": "1558a2a87f510cca4baaad5b", -"None": "1558a2a87f510cca4baaad5b", -"bigquery": "1558a2a87f510cca4baaad5b", -"databricks": "1558a2a87f510cca4baaad5b", +"None": "5865b96f5136d463181f63e4", +"bigquery": "5865b96f5136d463181f63e4", +"databricks": "5865b96f5136d463181f63e4", "duckdb": "1558a2a87f510cca4baaad5b", -"generic": "1558a2a87f510cca4baaad5b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1558a2a87f510cca4baaad5b", +"generic": "5865b96f5136d463181f63e4", +"motherduck": "1558a2a87f510cca4baaad5b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1558a2a87f510cca4baaad5b", "postgresql": "1558a2a87f510cca4baaad5b", "snowflake": "67b5874a2c569226c490211f", -"tsql": "1558a2a87f510cca4baaad5b" +"tsql": "5865b96f5136d463181f63e4" } ], [ @@ -18606,8 +18606,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "8441d00030df06ad6a5534d3", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "8441d00030df06ad6a5534d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -18623,8 +18623,8 @@ "databricks": "f43dac38f34a1c0618a3f812", "duckdb": "f43dac38f34a1c0618a3f812", "generic": "f43dac38f34a1c0618a3f812", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f43dac38f34a1c0618a3f812", +"motherduck": "f43dac38f34a1c0618a3f812", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f43dac38f34a1c0618a3f812", "postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "f43dac38f34a1c0618a3f812", @@ -18640,8 +18640,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -18657,8 +18657,8 @@ "databricks": "d043825e95555167dc033b5f", "duckdb": "d043825e95555167dc033b5f", "generic": "d043825e95555167dc033b5f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d043825e95555167dc033b5f", +"motherduck": "d043825e95555167dc033b5f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d043825e95555167dc033b5f", "postgresql": "d043825e95555167dc033b5f", "snowflake": "d043825e95555167dc033b5f", @@ -18674,8 +18674,8 @@ "databricks": "84e86bec7646b6ad19ceef59", "duckdb": "6a2162b5abe5a73734c47041", "generic": "6a2162b5abe5a73734c47041", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6a2162b5abe5a73734c47041", +"motherduck": "6a2162b5abe5a73734c47041", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6a2162b5abe5a73734c47041", "postgresql": "6a2162b5abe5a73734c47041", "snowflake": "16d902e899040d0c0c9dcf58", @@ -18691,8 +18691,8 @@ "databricks": "56245289768b0fb155df9ffd", "duckdb": "56245289768b0fb155df9ffd", "generic": "56245289768b0fb155df9ffd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "56245289768b0fb155df9ffd", +"motherduck": "56245289768b0fb155df9ffd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "56245289768b0fb155df9ffd", "postgresql": "56245289768b0fb155df9ffd", "snowflake": "56245289768b0fb155df9ffd", @@ -18708,8 +18708,8 @@ "databricks": "5abf4ec799a2ec32fb10da7e", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5abf4ec799a2ec32fb10da7e", "postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -18725,8 +18725,8 @@ "databricks": "362b5422259610d45387d0ab", "duckdb": "362b5422259610d45387d0ab", "generic": "362b5422259610d45387d0ab", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "362b5422259610d45387d0ab", +"motherduck": "362b5422259610d45387d0ab", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "362b5422259610d45387d0ab", "postgresql": "362b5422259610d45387d0ab", "snowflake": "362b5422259610d45387d0ab", @@ -18742,8 +18742,8 @@ "databricks": "b2c9b6ebca6c097f3caa0aa8", "duckdb": "b2c9b6ebca6c097f3caa0aa8", "generic": "b2c9b6ebca6c097f3caa0aa8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b2c9b6ebca6c097f3caa0aa8", +"motherduck": "b2c9b6ebca6c097f3caa0aa8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b2c9b6ebca6c097f3caa0aa8", "postgresql": "b2c9b6ebca6c097f3caa0aa8", "snowflake": "b2c9b6ebca6c097f3caa0aa8", @@ -18759,8 +18759,8 @@ "databricks": "b2c07944c578e7e9c9297bd8", "duckdb": "25f9faed41d5d23ca3fa8175", "generic": "25f9faed41d5d23ca3fa8175", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "25f9faed41d5d23ca3fa8175", +"motherduck": "25f9faed41d5d23ca3fa8175", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "25f9faed41d5d23ca3fa8175", "postgresql": "25f9faed41d5d23ca3fa8175", "snowflake": "fc6c5aa7025d9a737c71c606", @@ -18776,8 +18776,8 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "78b2cf275c640af54feeca31", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19bdd92ea0cc5fb028657510", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "78b2cf275c640af54feeca31", "postgresql": "78b2cf275c640af54feeca31", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -18793,8 +18793,8 @@ "databricks": "f7fca17b74cc50ae3de8c826", "duckdb": "f7fca17b74cc50ae3de8c826", "generic": "f7fca17b74cc50ae3de8c826", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f7fca17b74cc50ae3de8c826", +"motherduck": "f7fca17b74cc50ae3de8c826", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f7fca17b74cc50ae3de8c826", "postgresql": "f7fca17b74cc50ae3de8c826", "snowflake": "55155766823b6a3a5e882fc2", @@ -18810,8 +18810,8 @@ "databricks": "e7a76004da6461a939ce5fef", "duckdb": "e7a76004da6461a939ce5fef", "generic": "e7a76004da6461a939ce5fef", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e7a76004da6461a939ce5fef", +"motherduck": "e7a76004da6461a939ce5fef", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e7a76004da6461a939ce5fef", "postgresql": "e7a76004da6461a939ce5fef", "snowflake": "e7a76004da6461a939ce5fef", @@ -18827,8 +18827,8 @@ "databricks": "60a23b7dcae6c79f4de83068", "duckdb": "60a23b7dcae6c79f4de83068", "generic": "60a23b7dcae6c79f4de83068", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "60a23b7dcae6c79f4de83068", +"motherduck": "60a23b7dcae6c79f4de83068", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "60a23b7dcae6c79f4de83068", "postgresql": "60a23b7dcae6c79f4de83068", "snowflake": "60a23b7dcae6c79f4de83068", @@ -18844,8 +18844,8 @@ "databricks": "a47af75c6582f749e1d2b2e7", "duckdb": "a47af75c6582f749e1d2b2e7", "generic": "a47af75c6582f749e1d2b2e7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a47af75c6582f749e1d2b2e7", +"motherduck": "a47af75c6582f749e1d2b2e7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a47af75c6582f749e1d2b2e7", "postgresql": "a47af75c6582f749e1d2b2e7", "snowflake": "a47af75c6582f749e1d2b2e7", @@ -18861,8 +18861,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -18873,17 +18873,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -18895,8 +18895,8 @@ "databricks": "e1c74d96ac578f9323bf1bbd", "duckdb": "e1c74d96ac578f9323bf1bbd", "generic": "e1c74d96ac578f9323bf1bbd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e1c74d96ac578f9323bf1bbd", +"motherduck": "e1c74d96ac578f9323bf1bbd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e1c74d96ac578f9323bf1bbd", "postgresql": "e1c74d96ac578f9323bf1bbd", "snowflake": "e1c74d96ac578f9323bf1bbd", @@ -18912,8 +18912,8 @@ "databricks": "200c00626c910f6fd6177bb5", "duckdb": "200c00626c910f6fd6177bb5", "generic": "200c00626c910f6fd6177bb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "200c00626c910f6fd6177bb5", +"motherduck": "200c00626c910f6fd6177bb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "200c00626c910f6fd6177bb5", "postgresql": "200c00626c910f6fd6177bb5", "snowflake": "200c00626c910f6fd6177bb5", @@ -18929,8 +18929,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -18946,8 +18946,8 @@ "databricks": "fe0bedb7dda0e9247a51fdee", "duckdb": "fe0bedb7dda0e9247a51fdee", "generic": "fe0bedb7dda0e9247a51fdee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe0bedb7dda0e9247a51fdee", +"motherduck": "fe0bedb7dda0e9247a51fdee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fe0bedb7dda0e9247a51fdee", "postgresql": "fe0bedb7dda0e9247a51fdee", "snowflake": "fe0bedb7dda0e9247a51fdee", @@ -18963,8 +18963,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -18980,8 +18980,8 @@ "databricks": "c6889f2965db73017be6f6e7", "duckdb": "c6889f2965db73017be6f6e7", "generic": "c6889f2965db73017be6f6e7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6889f2965db73017be6f6e7", +"motherduck": "c6889f2965db73017be6f6e7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6889f2965db73017be6f6e7", "postgresql": "c6889f2965db73017be6f6e7", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -18997,10 +18997,10 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "aed0419e7f2ce7c0a8892248", "generic": "aed0419e7f2ce7c0a8892248", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aed0419e7f2ce7c0a8892248", -"postgres": "19e127c23b4598727a2d8ceb", -"postgresql": "19e127c23b4598727a2d8ceb", +"motherduck": "aed0419e7f2ce7c0a8892248", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "111af35848fe500ec2ae54b2", +"postgresql": "111af35848fe500ec2ae54b2", "snowflake": "aed0419e7f2ce7c0a8892248", "tsql": "aed0419e7f2ce7c0a8892248" } @@ -19014,8 +19014,8 @@ "databricks": "55a086bc8305ad303017ae10", "duckdb": "55a086bc8305ad303017ae10", "generic": "55a086bc8305ad303017ae10", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "55a086bc8305ad303017ae10", +"motherduck": "55a086bc8305ad303017ae10", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "55a086bc8305ad303017ae10", "postgresql": "55a086bc8305ad303017ae10", "snowflake": "55a086bc8305ad303017ae10", @@ -19031,10 +19031,10 @@ "databricks": "d08ef9483feed34fc0ee4319", "duckdb": "f7598fbf399afabe1e01a358", "generic": "d08ef9483feed34fc0ee4319", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d08ef9483feed34fc0ee4319", -"postgres": "d08ef9483feed34fc0ee4319", -"postgresql": "d08ef9483feed34fc0ee4319", +"motherduck": "f7598fbf399afabe1e01a358", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f7598fbf399afabe1e01a358", +"postgresql": "f7598fbf399afabe1e01a358", "snowflake": "d08ef9483feed34fc0ee4319", "tsql": "d08ef9483feed34fc0ee4319" } @@ -19048,8 +19048,8 @@ "databricks": "d3b6a6835220f9cedfa363c7", "duckdb": "d3b6a6835220f9cedfa363c7", "generic": "d3b6a6835220f9cedfa363c7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d3b6a6835220f9cedfa363c7", +"motherduck": "d3b6a6835220f9cedfa363c7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d3b6a6835220f9cedfa363c7", "postgresql": "d3b6a6835220f9cedfa363c7", "snowflake": "d3b6a6835220f9cedfa363c7", @@ -19065,8 +19065,8 @@ "databricks": "3d23f811a03db519b598c815", "duckdb": "3d23f811a03db519b598c815", "generic": "3d23f811a03db519b598c815", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3d23f811a03db519b598c815", +"motherduck": "3d23f811a03db519b598c815", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3d23f811a03db519b598c815", "postgresql": "3d23f811a03db519b598c815", "snowflake": "3d23f811a03db519b598c815", @@ -19082,8 +19082,8 @@ "databricks": "f816d7b3b97815f308346e20", "duckdb": "f816d7b3b97815f308346e20", "generic": "f816d7b3b97815f308346e20", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f816d7b3b97815f308346e20", +"motherduck": "f816d7b3b97815f308346e20", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f816d7b3b97815f308346e20", "postgresql": "f816d7b3b97815f308346e20", "snowflake": "f816d7b3b97815f308346e20", @@ -19099,10 +19099,10 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "aed0419e7f2ce7c0a8892248", "generic": "aed0419e7f2ce7c0a8892248", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aed0419e7f2ce7c0a8892248", -"postgres": "19e127c23b4598727a2d8ceb", -"postgresql": "19e127c23b4598727a2d8ceb", +"motherduck": "aed0419e7f2ce7c0a8892248", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "111af35848fe500ec2ae54b2", +"postgresql": "111af35848fe500ec2ae54b2", "snowflake": "aed0419e7f2ce7c0a8892248", "tsql": "aed0419e7f2ce7c0a8892248" } @@ -19116,8 +19116,8 @@ "databricks": "57922064a7dc546cbb50e42b", "duckdb": "57922064a7dc546cbb50e42b", "generic": "57922064a7dc546cbb50e42b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "57922064a7dc546cbb50e42b", +"motherduck": "57922064a7dc546cbb50e42b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "57922064a7dc546cbb50e42b", "postgresql": "57922064a7dc546cbb50e42b", "snowflake": "57922064a7dc546cbb50e42b", @@ -19128,17 +19128,17 @@ "type", { "DuckDB": "7b2fd741638cbd96bb38d7e0", -"None": "7b2fd741638cbd96bb38d7e0", -"bigquery": "7b2fd741638cbd96bb38d7e0", -"databricks": "4fb572024031cb7631777be1", +"None": "1e765712a4c0f6d3649350c6", +"bigquery": "1e765712a4c0f6d3649350c6", +"databricks": "1e765712a4c0f6d3649350c6", "duckdb": "7b2fd741638cbd96bb38d7e0", -"generic": "7b2fd741638cbd96bb38d7e0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7b2fd741638cbd96bb38d7e0", -"postgres": "7b2fd741638cbd96bb38d7e0", -"postgresql": "7b2fd741638cbd96bb38d7e0", +"generic": "1e765712a4c0f6d3649350c6", +"motherduck": "7b2fd741638cbd96bb38d7e0", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "1e765712a4c0f6d3649350c6", +"postgresql": "1e765712a4c0f6d3649350c6", "snowflake": "7b2fd741638cbd96bb38d7e0", -"tsql": "7b2fd741638cbd96bb38d7e0" +"tsql": "1e765712a4c0f6d3649350c6" } ], [ @@ -19150,8 +19150,8 @@ "databricks": "e4f0244beaa01667e80482b6", "duckdb": "a766fea06fc070b352976b0a", "generic": "a766fea06fc070b352976b0a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e4f0244beaa01667e80482b6", +"motherduck": "a766fea06fc070b352976b0a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a766fea06fc070b352976b0a", "postgresql": "a766fea06fc070b352976b0a", "snowflake": "a766fea06fc070b352976b0a", @@ -19167,8 +19167,8 @@ "databricks": "15b3387f6c4d73bcf113983a", "duckdb": "15b3387f6c4d73bcf113983a", "generic": "15b3387f6c4d73bcf113983a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "15b3387f6c4d73bcf113983a", +"motherduck": "15b3387f6c4d73bcf113983a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "15b3387f6c4d73bcf113983a", "postgresql": "15b3387f6c4d73bcf113983a", "snowflake": "15b3387f6c4d73bcf113983a", @@ -19181,11 +19181,11 @@ "DuckDB": "d34f84c1b71b9c9c0c20abb0", "None": "d34f84c1b71b9c9c0c20abb0", "bigquery": "d34f84c1b71b9c9c0c20abb0", -"databricks": "c662d9470aa4255dfb493df1", +"databricks": "d34f84c1b71b9c9c0c20abb0", "duckdb": "d34f84c1b71b9c9c0c20abb0", "generic": "d34f84c1b71b9c9c0c20abb0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c662d9470aa4255dfb493df1", +"motherduck": "d34f84c1b71b9c9c0c20abb0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d34f84c1b71b9c9c0c20abb0", "postgresql": "d34f84c1b71b9c9c0c20abb0", "snowflake": "d34f84c1b71b9c9c0c20abb0", @@ -19198,11 +19198,11 @@ "DuckDB": "14cd6e78d75f61b2bd1bbd71", "None": "14cd6e78d75f61b2bd1bbd71", "bigquery": "14cd6e78d75f61b2bd1bbd71", -"databricks": "73504f31156e8e661c1fb26c", +"databricks": "14cd6e78d75f61b2bd1bbd71", "duckdb": "14cd6e78d75f61b2bd1bbd71", "generic": "14cd6e78d75f61b2bd1bbd71", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73504f31156e8e661c1fb26c", +"motherduck": "14cd6e78d75f61b2bd1bbd71", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "14cd6e78d75f61b2bd1bbd71", "postgresql": "14cd6e78d75f61b2bd1bbd71", "snowflake": "14cd6e78d75f61b2bd1bbd71", @@ -19218,8 +19218,8 @@ "databricks": "96e8f438bf42d79cd8b1fada", "duckdb": "96e8f438bf42d79cd8b1fada", "generic": "96e8f438bf42d79cd8b1fada", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "96e8f438bf42d79cd8b1fada", +"motherduck": "96e8f438bf42d79cd8b1fada", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "96e8f438bf42d79cd8b1fada", "postgresql": "96e8f438bf42d79cd8b1fada", "snowflake": "96e8f438bf42d79cd8b1fada", @@ -19235,8 +19235,8 @@ "databricks": "260b29f255364b2044abe127", "duckdb": "260b29f255364b2044abe127", "generic": "260b29f255364b2044abe127", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "260b29f255364b2044abe127", +"motherduck": "260b29f255364b2044abe127", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "260b29f255364b2044abe127", "postgresql": "260b29f255364b2044abe127", "snowflake": "260b29f255364b2044abe127", @@ -19248,12 +19248,12 @@ { "DuckDB": "e5199d22ebbd1383c1e821df", "None": "e5199d22ebbd1383c1e821df", -"bigquery": "e5199d22ebbd1383c1e821df", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "e5199d22ebbd1383c1e821df", "duckdb": "e5199d22ebbd1383c1e821df", "generic": "e5199d22ebbd1383c1e821df", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e5199d22ebbd1383c1e821df", +"motherduck": "e5199d22ebbd1383c1e821df", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e5199d22ebbd1383c1e821df", "postgresql": "e5199d22ebbd1383c1e821df", "snowflake": "e5199d22ebbd1383c1e821df", @@ -19269,10 +19269,10 @@ "databricks": "336fd1b7a1f7d8105c29280c", "duckdb": "0baaca265927140414f32b37", "generic": "336fd1b7a1f7d8105c29280c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "336fd1b7a1f7d8105c29280c", -"postgres": "336fd1b7a1f7d8105c29280c", -"postgresql": "336fd1b7a1f7d8105c29280c", +"motherduck": "0baaca265927140414f32b37", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9ea4932505663b43f527adad", +"postgresql": "9ea4932505663b43f527adad", "snowflake": "336fd1b7a1f7d8105c29280c", "tsql": "336fd1b7a1f7d8105c29280c" } @@ -19286,8 +19286,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -19303,8 +19303,8 @@ "databricks": "802f1c1fcb97ddd5679172d2", "duckdb": "802f1c1fcb97ddd5679172d2", "generic": "802f1c1fcb97ddd5679172d2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "802f1c1fcb97ddd5679172d2", +"motherduck": "802f1c1fcb97ddd5679172d2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "802f1c1fcb97ddd5679172d2", "postgresql": "802f1c1fcb97ddd5679172d2", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -19320,8 +19320,8 @@ "databricks": "d91c8f17eb347629690400c7", "duckdb": "d91c8f17eb347629690400c7", "generic": "d91c8f17eb347629690400c7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d91c8f17eb347629690400c7", +"motherduck": "d91c8f17eb347629690400c7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d91c8f17eb347629690400c7", "postgresql": "d91c8f17eb347629690400c7", "snowflake": "d91c8f17eb347629690400c7", @@ -19337,8 +19337,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -19349,17 +19349,17 @@ "type", { "DuckDB": "314ed506f24e92300a425780", -"None": "314ed506f24e92300a425780", -"bigquery": "314ed506f24e92300a425780", -"databricks": "314ed506f24e92300a425780", +"None": "9a66317fb8d040bf991502c0", +"bigquery": "9bafb08d41fd1c208b5deca4", +"databricks": "9a66317fb8d040bf991502c0", "duckdb": "314ed506f24e92300a425780", -"generic": "314ed506f24e92300a425780", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "314ed506f24e92300a425780", +"generic": "9a66317fb8d040bf991502c0", +"motherduck": "314ed506f24e92300a425780", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "314ed506f24e92300a425780", "postgresql": "314ed506f24e92300a425780", "snowflake": "314ed506f24e92300a425780", -"tsql": "314ed506f24e92300a425780" +"tsql": "9a66317fb8d040bf991502c0" } ], [ @@ -19371,8 +19371,8 @@ "databricks": "2873244018c69d6d42752bdc", "duckdb": "2873244018c69d6d42752bdc", "generic": "2873244018c69d6d42752bdc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2873244018c69d6d42752bdc", +"motherduck": "2873244018c69d6d42752bdc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2873244018c69d6d42752bdc", "postgresql": "2873244018c69d6d42752bdc", "snowflake": "2873244018c69d6d42752bdc", @@ -19388,8 +19388,8 @@ "databricks": "3d23f811a03db519b598c815", "duckdb": "3d23f811a03db519b598c815", "generic": "3d23f811a03db519b598c815", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3d23f811a03db519b598c815", +"motherduck": "3d23f811a03db519b598c815", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3d23f811a03db519b598c815", "postgresql": "3d23f811a03db519b598c815", "snowflake": "3d23f811a03db519b598c815", @@ -19400,17 +19400,17 @@ "type", { "DuckDB": "087a9417cb511ff7bcfd6ccb", -"None": "383f8922f4b6f167d384037d", -"bigquery": "383f8922f4b6f167d384037d", -"databricks": "383f8922f4b6f167d384037d", +"None": "2e8f6dfec4597fb9373329e7", +"bigquery": "2e8f6dfec4597fb9373329e7", +"databricks": "2e8f6dfec4597fb9373329e7", "duckdb": "087a9417cb511ff7bcfd6ccb", -"generic": "383f8922f4b6f167d384037d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "383f8922f4b6f167d384037d", +"generic": "2e8f6dfec4597fb9373329e7", +"motherduck": "087a9417cb511ff7bcfd6ccb", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "383f8922f4b6f167d384037d", "postgresql": "383f8922f4b6f167d384037d", "snowflake": "383f8922f4b6f167d384037d", -"tsql": "383f8922f4b6f167d384037d" +"tsql": "2e8f6dfec4597fb9373329e7" } ], [ @@ -19422,10 +19422,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -19435,12 +19435,12 @@ { "DuckDB": "b017fb3c48f125e51b6db123", "None": "b017fb3c48f125e51b6db123", -"bigquery": "b017fb3c48f125e51b6db123", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "b017fb3c48f125e51b6db123", "duckdb": "b017fb3c48f125e51b6db123", "generic": "b017fb3c48f125e51b6db123", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b017fb3c48f125e51b6db123", +"motherduck": "b017fb3c48f125e51b6db123", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b017fb3c48f125e51b6db123", "postgresql": "b017fb3c48f125e51b6db123", "snowflake": "b017fb3c48f125e51b6db123", @@ -19456,8 +19456,8 @@ "databricks": "a7120d1b1abcb844c87a968a", "duckdb": "a7120d1b1abcb844c87a968a", "generic": "a7120d1b1abcb844c87a968a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a7120d1b1abcb844c87a968a", +"motherduck": "a7120d1b1abcb844c87a968a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a7120d1b1abcb844c87a968a", "postgresql": "a7120d1b1abcb844c87a968a", "snowflake": "a7120d1b1abcb844c87a968a", @@ -19473,8 +19473,8 @@ "databricks": "fd31c8e468772027804119ec", "duckdb": "fd31c8e468772027804119ec", "generic": "fd31c8e468772027804119ec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fd31c8e468772027804119ec", +"motherduck": "fd31c8e468772027804119ec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fd31c8e468772027804119ec", "postgresql": "fd31c8e468772027804119ec", "snowflake": "fd31c8e468772027804119ec", @@ -19490,8 +19490,8 @@ "databricks": "4169d9651c2a3667fc561f32", "duckdb": "4169d9651c2a3667fc561f32", "generic": "4169d9651c2a3667fc561f32", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4169d9651c2a3667fc561f32", +"motherduck": "4169d9651c2a3667fc561f32", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4169d9651c2a3667fc561f32", "postgresql": "4169d9651c2a3667fc561f32", "snowflake": "b210f8eb26c37b422f786c6b", @@ -19507,8 +19507,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -19524,10 +19524,10 @@ "databricks": "eed0645c1e86fa1a6e35ccaa", "duckdb": "eed0645c1e86fa1a6e35ccaa", "generic": "eed0645c1e86fa1a6e35ccaa", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "eed0645c1e86fa1a6e35ccaa", -"postgres": "eed0645c1e86fa1a6e35ccaa", -"postgresql": "eed0645c1e86fa1a6e35ccaa", +"motherduck": "eed0645c1e86fa1a6e35ccaa", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "b0477b36767a62145aa9158c", +"postgresql": "b0477b36767a62145aa9158c", "snowflake": "97a20344d811fb77c7690863", "tsql": "eed0645c1e86fa1a6e35ccaa" } @@ -19537,14 +19537,14 @@ { "DuckDB": "3a7ffeb8f81df6ccd57f3689", "None": "3a7ffeb8f81df6ccd57f3689", -"bigquery": "3a7ffeb8f81df6ccd57f3689", +"bigquery": "67d251c042daee0bb2bf7351", "databricks": "3a7ffeb8f81df6ccd57f3689", "duckdb": "3a7ffeb8f81df6ccd57f3689", "generic": "3a7ffeb8f81df6ccd57f3689", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3a7ffeb8f81df6ccd57f3689", -"postgres": "3a7ffeb8f81df6ccd57f3689", -"postgresql": "3a7ffeb8f81df6ccd57f3689", +"motherduck": "3a7ffeb8f81df6ccd57f3689", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "062e51ec86ccd542eb78500d", +"postgresql": "062e51ec86ccd542eb78500d", "snowflake": "3a7ffeb8f81df6ccd57f3689", "tsql": "3a7ffeb8f81df6ccd57f3689" } @@ -19558,8 +19558,8 @@ "databricks": "e1c74d96ac578f9323bf1bbd", "duckdb": "e1c74d96ac578f9323bf1bbd", "generic": "e1c74d96ac578f9323bf1bbd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e1c74d96ac578f9323bf1bbd", +"motherduck": "e1c74d96ac578f9323bf1bbd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e1c74d96ac578f9323bf1bbd", "postgresql": "e1c74d96ac578f9323bf1bbd", "snowflake": "e1c74d96ac578f9323bf1bbd", @@ -19569,16 +19569,16 @@ [ "type", { -"DuckDB": "e69f24e5693aeece1e1a03b8", -"None": "6dd6559eebacf5e375e1cce3", -"bigquery": "3e76afa61378ff263b617c7e", -"databricks": "e4317ab2bb471f29ee3c44be", -"duckdb": "e69f24e5693aeece1e1a03b8", -"generic": "6dd6559eebacf5e375e1cce3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6dd6559eebacf5e375e1cce3", -"postgres": "6dd6559eebacf5e375e1cce3", -"postgresql": "6dd6559eebacf5e375e1cce3", +"DuckDB": "427810237ffbfe3ee6dbe0d4", +"None": "6f2f02617b722e48d3f365c2", +"bigquery": "6f2f02617b722e48d3f365c2", +"databricks": "69ec26c1982add4704b948a6", +"duckdb": "427810237ffbfe3ee6dbe0d4", +"generic": "6f2f02617b722e48d3f365c2", +"motherduck": "427810237ffbfe3ee6dbe0d4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "6f2f02617b722e48d3f365c2", +"postgresql": "6f2f02617b722e48d3f365c2", "snowflake": "a4325ee9f4d61463eb81badb", "tsql": "6f2f02617b722e48d3f365c2" } @@ -19592,8 +19592,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -19605,14 +19605,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -19626,10 +19626,10 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "b8321619b794db091c9e96a1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b8321619b794db091c9e96a1", -"postgres": "b8321619b794db091c9e96a1", -"postgresql": "b8321619b794db091c9e96a1", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "bce26544873d6ec9191c9a86", +"postgresql": "bce26544873d6ec9191c9a86", "snowflake": "b8321619b794db091c9e96a1", "tsql": "b8321619b794db091c9e96a1" } @@ -19643,8 +19643,8 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "19a1a80ffc06169f32694de8", "postgresql": "19a1a80ffc06169f32694de8", "snowflake": "19a1a80ffc06169f32694de8", @@ -19660,8 +19660,8 @@ "databricks": "26e762643db86e7646e57cba", "duckdb": "26e762643db86e7646e57cba", "generic": "26e762643db86e7646e57cba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "26e762643db86e7646e57cba", +"motherduck": "26e762643db86e7646e57cba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "26e762643db86e7646e57cba", "postgresql": "26e762643db86e7646e57cba", "snowflake": "26e762643db86e7646e57cba", @@ -19677,8 +19677,8 @@ "databricks": "078c0e4b25cdb89eb4ebd88f", "duckdb": "078c0e4b25cdb89eb4ebd88f", "generic": "078c0e4b25cdb89eb4ebd88f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "078c0e4b25cdb89eb4ebd88f", +"motherduck": "078c0e4b25cdb89eb4ebd88f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "078c0e4b25cdb89eb4ebd88f", "postgresql": "078c0e4b25cdb89eb4ebd88f", "snowflake": "6306b9e88f7b13dbb6a32c00", @@ -19690,14 +19690,14 @@ { "DuckDB": "7cd31289a5b99b5a5e24492d", "None": "7cd31289a5b99b5a5e24492d", -"bigquery": "7cd31289a5b99b5a5e24492d", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "7cd31289a5b99b5a5e24492d", "duckdb": "7cd31289a5b99b5a5e24492d", "generic": "7cd31289a5b99b5a5e24492d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7cd31289a5b99b5a5e24492d", -"postgres": "7cd31289a5b99b5a5e24492d", -"postgresql": "7cd31289a5b99b5a5e24492d", +"motherduck": "7cd31289a5b99b5a5e24492d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "c5bdaf88df7ef3d9ae693106", +"postgresql": "c5bdaf88df7ef3d9ae693106", "snowflake": "7cd31289a5b99b5a5e24492d", "tsql": "7cd31289a5b99b5a5e24492d" } @@ -19711,8 +19711,8 @@ "databricks": "251aba3fef503ce64556c701", "duckdb": "251aba3fef503ce64556c701", "generic": "251aba3fef503ce64556c701", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "251aba3fef503ce64556c701", +"motherduck": "251aba3fef503ce64556c701", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b7d6fc051a3c1ea6deb29ff4", "postgresql": "b7d6fc051a3c1ea6deb29ff4", "snowflake": "251aba3fef503ce64556c701", @@ -19728,8 +19728,8 @@ "databricks": "3eb44072dafa3bef75c97b6a", "duckdb": "3eb44072dafa3bef75c97b6a", "generic": "3eb44072dafa3bef75c97b6a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3eb44072dafa3bef75c97b6a", +"motherduck": "3eb44072dafa3bef75c97b6a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3eb44072dafa3bef75c97b6a", "postgresql": "3eb44072dafa3bef75c97b6a", "snowflake": "3eb44072dafa3bef75c97b6a", @@ -19745,8 +19745,8 @@ "databricks": "596dafb6039bd1951f03c6a3", "duckdb": "596dafb6039bd1951f03c6a3", "generic": "596dafb6039bd1951f03c6a3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "596dafb6039bd1951f03c6a3", +"motherduck": "596dafb6039bd1951f03c6a3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0d0c279c483ce8c07a9e7375", "postgresql": "0d0c279c483ce8c07a9e7375", "snowflake": "596dafb6039bd1951f03c6a3", @@ -19762,8 +19762,8 @@ "databricks": "b2c9b6ebca6c097f3caa0aa8", "duckdb": "b2c9b6ebca6c097f3caa0aa8", "generic": "b2c9b6ebca6c097f3caa0aa8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b2c9b6ebca6c097f3caa0aa8", +"motherduck": "b2c9b6ebca6c097f3caa0aa8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b2c9b6ebca6c097f3caa0aa8", "postgresql": "b2c9b6ebca6c097f3caa0aa8", "snowflake": "b2c9b6ebca6c097f3caa0aa8", @@ -19775,14 +19775,14 @@ { "DuckDB": "d2c97d221599d038d9875873", "None": "d2c97d221599d038d9875873", -"bigquery": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", "databricks": "d2c97d221599d038d9875873", "duckdb": "d2c97d221599d038d9875873", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "d2c97d221599d038d9875873", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -19796,8 +19796,8 @@ "databricks": "4d90ccac34ef123bb0b2a15c", "duckdb": "4d90ccac34ef123bb0b2a15c", "generic": "4d90ccac34ef123bb0b2a15c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4d90ccac34ef123bb0b2a15c", +"motherduck": "4d90ccac34ef123bb0b2a15c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4d90ccac34ef123bb0b2a15c", "postgresql": "4d90ccac34ef123bb0b2a15c", "snowflake": "4d90ccac34ef123bb0b2a15c", @@ -19813,8 +19813,8 @@ "databricks": "1ae302067c05dc9ae3a029f2", "duckdb": "1ae302067c05dc9ae3a029f2", "generic": "1ae302067c05dc9ae3a029f2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1ae302067c05dc9ae3a029f2", +"motherduck": "1ae302067c05dc9ae3a029f2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1ae302067c05dc9ae3a029f2", "postgresql": "1ae302067c05dc9ae3a029f2", "snowflake": "1ae302067c05dc9ae3a029f2", @@ -19830,8 +19830,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "8441d00030df06ad6a5534d3", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "8441d00030df06ad6a5534d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -19847,8 +19847,8 @@ "databricks": "b1ec979036647e3f2686cece", "duckdb": "b1ec979036647e3f2686cece", "generic": "b1ec979036647e3f2686cece", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b1ec979036647e3f2686cece", +"motherduck": "b1ec979036647e3f2686cece", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b1ec979036647e3f2686cece", "postgresql": "b1ec979036647e3f2686cece", "snowflake": "b1ec979036647e3f2686cece", @@ -19864,8 +19864,8 @@ "databricks": "962ea05bab624c1f8c259a65", "duckdb": "962ea05bab624c1f8c259a65", "generic": "962ea05bab624c1f8c259a65", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "962ea05bab624c1f8c259a65", +"motherduck": "962ea05bab624c1f8c259a65", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "962ea05bab624c1f8c259a65", "postgresql": "962ea05bab624c1f8c259a65", "snowflake": "962ea05bab624c1f8c259a65", @@ -19877,14 +19877,14 @@ { "DuckDB": "f319941cc6ec088f46ecbadb", "None": "f319941cc6ec088f46ecbadb", -"bigquery": "f319941cc6ec088f46ecbadb", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "f319941cc6ec088f46ecbadb", "duckdb": "f319941cc6ec088f46ecbadb", "generic": "f319941cc6ec088f46ecbadb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f319941cc6ec088f46ecbadb", -"postgres": "f319941cc6ec088f46ecbadb", -"postgresql": "f319941cc6ec088f46ecbadb", +"motherduck": "f319941cc6ec088f46ecbadb", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e664f46cfdd4441496e27023", +"postgresql": "e664f46cfdd4441496e27023", "snowflake": "f319941cc6ec088f46ecbadb", "tsql": "f319941cc6ec088f46ecbadb" } @@ -19898,8 +19898,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -19915,8 +19915,8 @@ "databricks": "717cf79ef777823eb3576deb", "duckdb": "717cf79ef777823eb3576deb", "generic": "717cf79ef777823eb3576deb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "717cf79ef777823eb3576deb", +"motherduck": "717cf79ef777823eb3576deb", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "717cf79ef777823eb3576deb", "postgresql": "717cf79ef777823eb3576deb", "snowflake": "717cf79ef777823eb3576deb", @@ -19932,8 +19932,8 @@ "databricks": "8362a1ff79ce7c9350d11210", "duckdb": "8362a1ff79ce7c9350d11210", "generic": "8362a1ff79ce7c9350d11210", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8362a1ff79ce7c9350d11210", +"motherduck": "8362a1ff79ce7c9350d11210", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8362a1ff79ce7c9350d11210", "postgresql": "8362a1ff79ce7c9350d11210", "snowflake": "8362a1ff79ce7c9350d11210", @@ -19949,8 +19949,8 @@ "databricks": "688179272da645629077e980", "duckdb": "688179272da645629077e980", "generic": "688179272da645629077e980", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "688179272da645629077e980", +"motherduck": "688179272da645629077e980", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "688179272da645629077e980", "postgresql": "688179272da645629077e980", "snowflake": "b210f8eb26c37b422f786c6b", @@ -19966,8 +19966,8 @@ "databricks": "2e5b1ffe62d65d4d8c389ecd", "duckdb": "2e5b1ffe62d65d4d8c389ecd", "generic": "2e5b1ffe62d65d4d8c389ecd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2e5b1ffe62d65d4d8c389ecd", +"motherduck": "2e5b1ffe62d65d4d8c389ecd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2e5b1ffe62d65d4d8c389ecd", "postgresql": "2e5b1ffe62d65d4d8c389ecd", "snowflake": "2e5b1ffe62d65d4d8c389ecd", @@ -19983,8 +19983,8 @@ "databricks": "e6badc927d1adf4563b4f3a5", "duckdb": "e6badc927d1adf4563b4f3a5", "generic": "e6badc927d1adf4563b4f3a5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e6badc927d1adf4563b4f3a5", +"motherduck": "e6badc927d1adf4563b4f3a5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e6badc927d1adf4563b4f3a5", "postgresql": "e6badc927d1adf4563b4f3a5", "snowflake": "e6badc927d1adf4563b4f3a5", @@ -20000,8 +20000,8 @@ "databricks": "9070740b5c7f7fb5d091ad05", "duckdb": "9070740b5c7f7fb5d091ad05", "generic": "9070740b5c7f7fb5d091ad05", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9070740b5c7f7fb5d091ad05", +"motherduck": "9070740b5c7f7fb5d091ad05", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9070740b5c7f7fb5d091ad05", "postgresql": "9070740b5c7f7fb5d091ad05", "snowflake": "9070740b5c7f7fb5d091ad05", @@ -20014,11 +20014,11 @@ "DuckDB": "607f7c82658f39cce394b124", "None": "607f7c82658f39cce394b124", "bigquery": "607f7c82658f39cce394b124", -"databricks": "085a20ac29ebf425cac9e1d7", +"databricks": "607f7c82658f39cce394b124", "duckdb": "607f7c82658f39cce394b124", "generic": "607f7c82658f39cce394b124", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "085a20ac29ebf425cac9e1d7", +"motherduck": "607f7c82658f39cce394b124", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "607f7c82658f39cce394b124", "postgresql": "607f7c82658f39cce394b124", "snowflake": "607f7c82658f39cce394b124", @@ -20030,12 +20030,12 @@ { "DuckDB": "b3d92948d21d50dcbeb5f80b", "None": "b3d92948d21d50dcbeb5f80b", -"bigquery": "b3d92948d21d50dcbeb5f80b", +"bigquery": "e8b4e369659058a182f86446", "databricks": "b3d92948d21d50dcbeb5f80b", "duckdb": "b3d92948d21d50dcbeb5f80b", "generic": "b3d92948d21d50dcbeb5f80b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b3d92948d21d50dcbeb5f80b", +"motherduck": "b3d92948d21d50dcbeb5f80b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b3d92948d21d50dcbeb5f80b", "postgresql": "b3d92948d21d50dcbeb5f80b", "snowflake": "b3d92948d21d50dcbeb5f80b", @@ -20046,17 +20046,17 @@ "type", { "DuckDB": "c50a316d091c821866e4bfba", -"None": "c50a316d091c821866e4bfba", -"bigquery": "c50a316d091c821866e4bfba", -"databricks": "c50a316d091c821866e4bfba", +"None": "e6ffdece2977be55da73b59a", +"bigquery": "e6ffdece2977be55da73b59a", +"databricks": "e6ffdece2977be55da73b59a", "duckdb": "c50a316d091c821866e4bfba", -"generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"generic": "e6ffdece2977be55da73b59a", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", -"tsql": "c50a316d091c821866e4bfba" +"tsql": "e6ffdece2977be55da73b59a" } ], [ @@ -20068,8 +20068,8 @@ "databricks": "f4c43a87a78970bca1f88b09", "duckdb": "f4c43a87a78970bca1f88b09", "generic": "f4c43a87a78970bca1f88b09", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f4c43a87a78970bca1f88b09", +"motherduck": "f4c43a87a78970bca1f88b09", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f4c43a87a78970bca1f88b09", "postgresql": "f4c43a87a78970bca1f88b09", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -20085,8 +20085,8 @@ "databricks": "2279ed9a279f48d8451671cf", "duckdb": "2279ed9a279f48d8451671cf", "generic": "2279ed9a279f48d8451671cf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2279ed9a279f48d8451671cf", +"motherduck": "2279ed9a279f48d8451671cf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2279ed9a279f48d8451671cf", "postgresql": "2279ed9a279f48d8451671cf", "snowflake": "2279ed9a279f48d8451671cf", @@ -20098,14 +20098,14 @@ { "DuckDB": "881106a4a0d2de0ff7c56373", "None": "881106a4a0d2de0ff7c56373", -"bigquery": "881106a4a0d2de0ff7c56373", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "881106a4a0d2de0ff7c56373", "duckdb": "881106a4a0d2de0ff7c56373", "generic": "881106a4a0d2de0ff7c56373", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "881106a4a0d2de0ff7c56373", -"postgres": "881106a4a0d2de0ff7c56373", -"postgresql": "881106a4a0d2de0ff7c56373", +"motherduck": "881106a4a0d2de0ff7c56373", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "cf167ec395fc843602e3b1e0", +"postgresql": "cf167ec395fc843602e3b1e0", "snowflake": "881106a4a0d2de0ff7c56373", "tsql": "881106a4a0d2de0ff7c56373" } @@ -20114,17 +20114,17 @@ "type", { "DuckDB": "f46cf4b4e131aa122b5b33d6", -"None": "f46cf4b4e131aa122b5b33d6", -"bigquery": "f46cf4b4e131aa122b5b33d6", -"databricks": "f46cf4b4e131aa122b5b33d6", +"None": "f774d5e8feadbf11edaa26b1", +"bigquery": "9bafb08d41fd1c208b5deca4", +"databricks": "f774d5e8feadbf11edaa26b1", "duckdb": "f46cf4b4e131aa122b5b33d6", -"generic": "f46cf4b4e131aa122b5b33d6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f46cf4b4e131aa122b5b33d6", +"generic": "f774d5e8feadbf11edaa26b1", +"motherduck": "f46cf4b4e131aa122b5b33d6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f46cf4b4e131aa122b5b33d6", "postgresql": "f46cf4b4e131aa122b5b33d6", "snowflake": "f46cf4b4e131aa122b5b33d6", -"tsql": "f46cf4b4e131aa122b5b33d6" +"tsql": "f774d5e8feadbf11edaa26b1" } ], [ @@ -20136,8 +20136,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "8441d00030df06ad6a5534d3", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "8441d00030df06ad6a5534d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -20153,8 +20153,8 @@ "databricks": "0475b57e9e9da81e87fa09ba", "duckdb": "0475b57e9e9da81e87fa09ba", "generic": "0475b57e9e9da81e87fa09ba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0475b57e9e9da81e87fa09ba", +"motherduck": "0475b57e9e9da81e87fa09ba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0475b57e9e9da81e87fa09ba", "postgresql": "0475b57e9e9da81e87fa09ba", "snowflake": "0475b57e9e9da81e87fa09ba", @@ -20170,8 +20170,8 @@ "databricks": "43e3e82e80c9c1580eb61a1d", "duckdb": "43e3e82e80c9c1580eb61a1d", "generic": "43e3e82e80c9c1580eb61a1d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "43e3e82e80c9c1580eb61a1d", +"motherduck": "43e3e82e80c9c1580eb61a1d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "43e3e82e80c9c1580eb61a1d", "postgresql": "43e3e82e80c9c1580eb61a1d", "snowflake": "43e3e82e80c9c1580eb61a1d", @@ -20187,8 +20187,8 @@ "databricks": "846f4ee64c34aab0cdabb9a0", "duckdb": "51b0e597909858f7f7aa4571", "generic": "51b0e597909858f7f7aa4571", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "51b0e597909858f7f7aa4571", +"motherduck": "51b0e597909858f7f7aa4571", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "51b0e597909858f7f7aa4571", "postgresql": "51b0e597909858f7f7aa4571", "snowflake": "4d94d72d93a870dcc1521bee", @@ -20204,8 +20204,8 @@ "databricks": "962ea05bab624c1f8c259a65", "duckdb": "962ea05bab624c1f8c259a65", "generic": "962ea05bab624c1f8c259a65", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "962ea05bab624c1f8c259a65", +"motherduck": "962ea05bab624c1f8c259a65", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "962ea05bab624c1f8c259a65", "postgresql": "962ea05bab624c1f8c259a65", "snowflake": "962ea05bab624c1f8c259a65", @@ -20221,8 +20221,8 @@ "databricks": "1275b5b0c52f69cf592c004b", "duckdb": "1275b5b0c52f69cf592c004b", "generic": "1275b5b0c52f69cf592c004b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1275b5b0c52f69cf592c004b", +"motherduck": "1275b5b0c52f69cf592c004b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1275b5b0c52f69cf592c004b", "postgresql": "1275b5b0c52f69cf592c004b", "snowflake": "1275b5b0c52f69cf592c004b", @@ -20238,8 +20238,8 @@ "databricks": "11d9e4471b50590a198e94a1", "duckdb": "a01889d0707cf6b364efb5f9", "generic": "94834ae92073b4606184619b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "11d9e4471b50590a198e94a1", +"motherduck": "a01889d0707cf6b364efb5f9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a01889d0707cf6b364efb5f9", "postgresql": "a01889d0707cf6b364efb5f9", "snowflake": "5bc09c1a33ccb4bd2e4075e5", @@ -20255,10 +20255,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -20267,15 +20267,15 @@ "type", { "DuckDB": "c43574432afc90bcba6944b2", -"None": "bf431bf304d57dd7b16797df", -"bigquery": "bf431bf304d57dd7b16797df", -"databricks": "bf431bf304d57dd7b16797df", +"None": "ba3896413716dbcd432e62dd", +"bigquery": "ba3896413716dbcd432e62dd", +"databricks": "ba3896413716dbcd432e62dd", "duckdb": "c43574432afc90bcba6944b2", -"generic": "bf431bf304d57dd7b16797df", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "b462303a5e5a209df5a75e4b", -"postgresql": "b462303a5e5a209df5a75e4b", +"generic": "ba3896413716dbcd432e62dd", +"motherduck": "c43574432afc90bcba6944b2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ba3896413716dbcd432e62dd", +"postgresql": "ba3896413716dbcd432e62dd", "snowflake": "26094c8570001998e247761e", "tsql": "ba3896413716dbcd432e62dd" } @@ -20289,8 +20289,8 @@ "databricks": "d90a78129f7050a540984f6f", "duckdb": "66f7ca02161349d637fa7d4e", "generic": "66f7ca02161349d637fa7d4e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d90a78129f7050a540984f6f", +"motherduck": "66f7ca02161349d637fa7d4e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "66f7ca02161349d637fa7d4e", "postgresql": "66f7ca02161349d637fa7d4e", "snowflake": "66f7ca02161349d637fa7d4e", @@ -20306,8 +20306,8 @@ "databricks": "83fdbd1f0a6ee4e72faa4d94", "duckdb": "83fdbd1f0a6ee4e72faa4d94", "generic": "83fdbd1f0a6ee4e72faa4d94", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "83fdbd1f0a6ee4e72faa4d94", +"motherduck": "83fdbd1f0a6ee4e72faa4d94", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "83fdbd1f0a6ee4e72faa4d94", "postgresql": "83fdbd1f0a6ee4e72faa4d94", "snowflake": "83fdbd1f0a6ee4e72faa4d94", @@ -20323,10 +20323,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "e2879cf4770e7f48d2dd704a", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "e2879cf4770e7f48d2dd704a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -20340,8 +20340,8 @@ "databricks": "7c8df74df226e73b459bfdba", "duckdb": "7c8df74df226e73b459bfdba", "generic": "7c8df74df226e73b459bfdba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7c8df74df226e73b459bfdba", +"motherduck": "7c8df74df226e73b459bfdba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7c8df74df226e73b459bfdba", "postgresql": "7c8df74df226e73b459bfdba", "snowflake": "7c8df74df226e73b459bfdba", @@ -20357,10 +20357,10 @@ "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "b0ce99394388f977f67fd1df", +"postgresql": "b0ce99394388f977f67fd1df", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -20370,14 +20370,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -20385,16 +20385,16 @@ [ "type", { -"DuckDB": "267fe8533e5d50f2cd3eb176", -"None": "8e0e269b33b63f52e24399e2", -"bigquery": "6a9a0937e74ae8ee83e705e4", -"databricks": "6a9a0937e74ae8ee83e705e4", -"duckdb": "267fe8533e5d50f2cd3eb176", -"generic": "8e0e269b33b63f52e24399e2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "43767924372e86845ec63bb6", -"postgresql": "43767924372e86845ec63bb6", +"DuckDB": "627ea26821da68299a37ddb8", +"None": "69ccced5b5ccc61253f2656b", +"bigquery": "69ccced5b5ccc61253f2656b", +"databricks": "69ccced5b5ccc61253f2656b", +"duckdb": "627ea26821da68299a37ddb8", +"generic": "69ccced5b5ccc61253f2656b", +"motherduck": "627ea26821da68299a37ddb8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "69ccced5b5ccc61253f2656b", +"postgresql": "69ccced5b5ccc61253f2656b", "snowflake": "5a7da03d64d9bf65f9984782", "tsql": "69ccced5b5ccc61253f2656b" } @@ -20404,14 +20404,14 @@ { "DuckDB": "4920de3b1203a0d66fc1b3cd", "None": "4920de3b1203a0d66fc1b3cd", -"bigquery": "4920de3b1203a0d66fc1b3cd", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "4920de3b1203a0d66fc1b3cd", "duckdb": "4920de3b1203a0d66fc1b3cd", "generic": "4920de3b1203a0d66fc1b3cd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4920de3b1203a0d66fc1b3cd", -"postgres": "4920de3b1203a0d66fc1b3cd", -"postgresql": "4920de3b1203a0d66fc1b3cd", +"motherduck": "4920de3b1203a0d66fc1b3cd", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8682e002a09d580d930440bf", +"postgresql": "8682e002a09d580d930440bf", "snowflake": "4920de3b1203a0d66fc1b3cd", "tsql": "4920de3b1203a0d66fc1b3cd" } @@ -20425,8 +20425,8 @@ "databricks": "7914189ff18b0e70ddf7d042", "duckdb": "7914189ff18b0e70ddf7d042", "generic": "7914189ff18b0e70ddf7d042", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7914189ff18b0e70ddf7d042", +"motherduck": "7914189ff18b0e70ddf7d042", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7914189ff18b0e70ddf7d042", "postgresql": "7914189ff18b0e70ddf7d042", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -20442,8 +20442,8 @@ "databricks": "c6889f2965db73017be6f6e7", "duckdb": "c6889f2965db73017be6f6e7", "generic": "c6889f2965db73017be6f6e7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6889f2965db73017be6f6e7", +"motherduck": "c6889f2965db73017be6f6e7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6889f2965db73017be6f6e7", "postgresql": "c6889f2965db73017be6f6e7", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -20455,14 +20455,14 @@ { "DuckDB": "4d0f0db1a550ed1e0da1a043", "None": "4d0f0db1a550ed1e0da1a043", -"bigquery": "4d0f0db1a550ed1e0da1a043", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "4d0f0db1a550ed1e0da1a043", "duckdb": "4d0f0db1a550ed1e0da1a043", "generic": "4d0f0db1a550ed1e0da1a043", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4d0f0db1a550ed1e0da1a043", -"postgres": "4d0f0db1a550ed1e0da1a043", -"postgresql": "4d0f0db1a550ed1e0da1a043", +"motherduck": "4d0f0db1a550ed1e0da1a043", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e47320d1030c166a05193bc4", +"postgresql": "e47320d1030c166a05193bc4", "snowflake": "4d0f0db1a550ed1e0da1a043", "tsql": "4d0f0db1a550ed1e0da1a043" } @@ -20476,8 +20476,8 @@ "databricks": "a9d9e03f8e981cec9dca7694", "duckdb": "a9d9e03f8e981cec9dca7694", "generic": "a9d9e03f8e981cec9dca7694", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a9d9e03f8e981cec9dca7694", +"motherduck": "a9d9e03f8e981cec9dca7694", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a9d9e03f8e981cec9dca7694", "postgresql": "a9d9e03f8e981cec9dca7694", "snowflake": "a9d9e03f8e981cec9dca7694", @@ -20493,8 +20493,8 @@ "databricks": "95961ec6c293c3d6b6bf65ec", "duckdb": "95961ec6c293c3d6b6bf65ec", "generic": "95961ec6c293c3d6b6bf65ec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "95961ec6c293c3d6b6bf65ec", +"motherduck": "95961ec6c293c3d6b6bf65ec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "95961ec6c293c3d6b6bf65ec", "postgresql": "95961ec6c293c3d6b6bf65ec", "snowflake": "95961ec6c293c3d6b6bf65ec", @@ -20510,8 +20510,8 @@ "databricks": "2c5e4442c23cf9e2b37caa7e", "duckdb": "2c5e4442c23cf9e2b37caa7e", "generic": "2c5e4442c23cf9e2b37caa7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2c5e4442c23cf9e2b37caa7e", +"motherduck": "2c5e4442c23cf9e2b37caa7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2c5e4442c23cf9e2b37caa7e", "postgresql": "2c5e4442c23cf9e2b37caa7e", "snowflake": "2c5e4442c23cf9e2b37caa7e", @@ -20522,17 +20522,17 @@ "type", { "DuckDB": "a428302e4848ffe877284c84", -"None": "a428302e4848ffe877284c84", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "a428302e4848ffe877284c84", +"None": "c9b810639795a7bfab91b98d", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "c9b810639795a7bfab91b98d", "duckdb": "a428302e4848ffe877284c84", -"generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"generic": "c9b810639795a7bfab91b98d", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "a428302e4848ffe877284c84" +"tsql": "c9b810639795a7bfab91b98d" } ], [ @@ -20544,8 +20544,8 @@ "databricks": "1ebb508c9c012fda785eac26", "duckdb": "8702414b6372d27d90111c0d", "generic": "a7fcdf83ba95c5481cac4059", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1ebb508c9c012fda785eac26", +"motherduck": "8702414b6372d27d90111c0d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8702414b6372d27d90111c0d", "postgresql": "8702414b6372d27d90111c0d", "snowflake": "521d89d8efac986351afc368", @@ -20557,14 +20557,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -20578,8 +20578,8 @@ "databricks": "3dbbe73ee4310c73030e8110", "duckdb": "3dbbe73ee4310c73030e8110", "generic": "3dbbe73ee4310c73030e8110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3dbbe73ee4310c73030e8110", +"motherduck": "3dbbe73ee4310c73030e8110", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3dbbe73ee4310c73030e8110", "postgresql": "3dbbe73ee4310c73030e8110", "snowflake": "f43dac38f34a1c0618a3f812", @@ -20591,12 +20591,12 @@ { "DuckDB": "62368fc15cefd5807807b209", "None": "62368fc15cefd5807807b209", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "62368fc15cefd5807807b209", "duckdb": "62368fc15cefd5807807b209", "generic": "62368fc15cefd5807807b209", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "62368fc15cefd5807807b209", +"motherduck": "62368fc15cefd5807807b209", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "62368fc15cefd5807807b209", "postgresql": "62368fc15cefd5807807b209", "snowflake": "62368fc15cefd5807807b209", @@ -20612,8 +20612,8 @@ "databricks": "1bdf5908ca249b2331a0427c", "duckdb": "1bdf5908ca249b2331a0427c", "generic": "1bdf5908ca249b2331a0427c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1bdf5908ca249b2331a0427c", +"motherduck": "1bdf5908ca249b2331a0427c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1bdf5908ca249b2331a0427c", "postgresql": "1bdf5908ca249b2331a0427c", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -20625,12 +20625,12 @@ { "DuckDB": "dd061dac05d8a112fce62140", "None": "dd061dac05d8a112fce62140", -"bigquery": "dd061dac05d8a112fce62140", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "dd061dac05d8a112fce62140", "duckdb": "dd061dac05d8a112fce62140", "generic": "dd061dac05d8a112fce62140", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "dd061dac05d8a112fce62140", +"motherduck": "dd061dac05d8a112fce62140", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "dd061dac05d8a112fce62140", "postgresql": "dd061dac05d8a112fce62140", "snowflake": "dd061dac05d8a112fce62140", @@ -20642,12 +20642,12 @@ { "DuckDB": "d7b4d15e2e3140069c23e6d4", "None": "d7b4d15e2e3140069c23e6d4", -"bigquery": "ba82290eb0d38f9638b8b0dc", +"bigquery": "01d1b160c1768fa1cd4b2e45", "databricks": "9ce61cdfd35b2a8b31faa983", "duckdb": "d7b4d15e2e3140069c23e6d4", "generic": "d7b4d15e2e3140069c23e6d4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d7b4d15e2e3140069c23e6d4", +"motherduck": "d7b4d15e2e3140069c23e6d4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d7b4d15e2e3140069c23e6d4", "postgresql": "d7b4d15e2e3140069c23e6d4", "snowflake": "906644f12c56f91f8767953d", @@ -20663,8 +20663,8 @@ "databricks": "cd932c5de0731b5ff7bddd24", "duckdb": "cd932c5de0731b5ff7bddd24", "generic": "cd932c5de0731b5ff7bddd24", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cd932c5de0731b5ff7bddd24", +"motherduck": "cd932c5de0731b5ff7bddd24", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cd932c5de0731b5ff7bddd24", "postgresql": "cd932c5de0731b5ff7bddd24", "snowflake": "cd932c5de0731b5ff7bddd24", @@ -20680,8 +20680,8 @@ "databricks": "104d3e046c47032c37f947b8", "duckdb": "104d3e046c47032c37f947b8", "generic": "104d3e046c47032c37f947b8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "104d3e046c47032c37f947b8", +"motherduck": "104d3e046c47032c37f947b8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "104d3e046c47032c37f947b8", "postgresql": "104d3e046c47032c37f947b8", "snowflake": "104d3e046c47032c37f947b8", @@ -20697,8 +20697,8 @@ "databricks": "f179445103bc721a2dc04002", "duckdb": "f179445103bc721a2dc04002", "generic": "f179445103bc721a2dc04002", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f179445103bc721a2dc04002", +"motherduck": "f179445103bc721a2dc04002", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f179445103bc721a2dc04002", "postgresql": "f179445103bc721a2dc04002", "snowflake": "f179445103bc721a2dc04002", @@ -20714,8 +20714,8 @@ "databricks": "7a924f1a13854aa3260f3f57", "duckdb": "7a924f1a13854aa3260f3f57", "generic": "7a924f1a13854aa3260f3f57", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7a924f1a13854aa3260f3f57", +"motherduck": "7a924f1a13854aa3260f3f57", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7a924f1a13854aa3260f3f57", "postgresql": "7a924f1a13854aa3260f3f57", "snowflake": "7a924f1a13854aa3260f3f57", @@ -20731,10 +20731,10 @@ "databricks": "3d4143f0295abc5ed5a3d8cc", "duckdb": "3d4143f0295abc5ed5a3d8cc", "generic": "3d4143f0295abc5ed5a3d8cc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3d4143f0295abc5ed5a3d8cc", -"postgres": "3d4143f0295abc5ed5a3d8cc", -"postgresql": "3d4143f0295abc5ed5a3d8cc", +"motherduck": "3d4143f0295abc5ed5a3d8cc", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "359568909836c6e577ab7e8c", +"postgresql": "359568909836c6e577ab7e8c", "snowflake": "3d4143f0295abc5ed5a3d8cc", "tsql": "3d4143f0295abc5ed5a3d8cc" } @@ -20748,8 +20748,8 @@ "databricks": "3f71ab5f3c1c040da96f2cec", "duckdb": "3f71ab5f3c1c040da96f2cec", "generic": "3f71ab5f3c1c040da96f2cec", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3f71ab5f3c1c040da96f2cec", +"motherduck": "3f71ab5f3c1c040da96f2cec", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3f71ab5f3c1c040da96f2cec", "postgresql": "3f71ab5f3c1c040da96f2cec", "snowflake": "3f71ab5f3c1c040da96f2cec", @@ -20765,8 +20765,8 @@ "databricks": "d4a375fcf7c3190951992469", "duckdb": "d4a375fcf7c3190951992469", "generic": "d4a375fcf7c3190951992469", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d4a375fcf7c3190951992469", +"motherduck": "d4a375fcf7c3190951992469", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d4a375fcf7c3190951992469", "postgresql": "d4a375fcf7c3190951992469", "snowflake": "6306b9e88f7b13dbb6a32c00", @@ -20782,8 +20782,8 @@ "databricks": "78709b3317abd96cc20340f7", "duckdb": "78709b3317abd96cc20340f7", "generic": "78709b3317abd96cc20340f7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "78709b3317abd96cc20340f7", +"motherduck": "78709b3317abd96cc20340f7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "78709b3317abd96cc20340f7", "postgresql": "78709b3317abd96cc20340f7", "snowflake": "78709b3317abd96cc20340f7", @@ -20799,8 +20799,8 @@ "databricks": "652ff8b21f638eac8fdc46c5", "duckdb": "652ff8b21f638eac8fdc46c5", "generic": "652ff8b21f638eac8fdc46c5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "652ff8b21f638eac8fdc46c5", +"motherduck": "652ff8b21f638eac8fdc46c5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "652ff8b21f638eac8fdc46c5", "postgresql": "652ff8b21f638eac8fdc46c5", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -20816,8 +20816,8 @@ "databricks": "293fdb322059805900912bee", "duckdb": "293fdb322059805900912bee", "generic": "293fdb322059805900912bee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "293fdb322059805900912bee", +"motherduck": "293fdb322059805900912bee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "293fdb322059805900912bee", "postgresql": "293fdb322059805900912bee", "snowflake": "293fdb322059805900912bee", @@ -20833,8 +20833,8 @@ "databricks": "3d23f811a03db519b598c815", "duckdb": "3d23f811a03db519b598c815", "generic": "3d23f811a03db519b598c815", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3d23f811a03db519b598c815", +"motherduck": "3d23f811a03db519b598c815", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3d23f811a03db519b598c815", "postgresql": "3d23f811a03db519b598c815", "snowflake": "3d23f811a03db519b598c815", @@ -20850,8 +20850,8 @@ "databricks": "1231fdcee1164056bb998fd8", "duckdb": "9cf8454127727005f919e6fc", "generic": "9a5c2bd43f94970e2d4d2210", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "84e2dbd148c2ae9480447652", +"motherduck": "9cf8454127727005f919e6fc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "eaa1040a087ac34088fbabf6", "postgresql": "eaa1040a087ac34088fbabf6", "snowflake": "143732e0372eaf73cb82cfe7", @@ -20867,8 +20867,8 @@ "databricks": "2166772bfafca596e1de9d10", "duckdb": "2166772bfafca596e1de9d10", "generic": "2166772bfafca596e1de9d10", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2166772bfafca596e1de9d10", +"motherduck": "2166772bfafca596e1de9d10", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2166772bfafca596e1de9d10", "postgresql": "2166772bfafca596e1de9d10", "snowflake": "2166772bfafca596e1de9d10", @@ -20884,8 +20884,8 @@ "databricks": "8441d00030df06ad6a5534d3", "duckdb": "8441d00030df06ad6a5534d3", "generic": "8441d00030df06ad6a5534d3", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8441d00030df06ad6a5534d3", +"motherduck": "8441d00030df06ad6a5534d3", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8441d00030df06ad6a5534d3", "postgresql": "8441d00030df06ad6a5534d3", "snowflake": "97a20344d811fb77c7690863", @@ -20901,8 +20901,8 @@ "databricks": "013a8446f043affffcf194f8", "duckdb": "013a8446f043affffcf194f8", "generic": "013a8446f043affffcf194f8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "013a8446f043affffcf194f8", +"motherduck": "013a8446f043affffcf194f8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "013a8446f043affffcf194f8", "postgresql": "013a8446f043affffcf194f8", "snowflake": "97a20344d811fb77c7690863", @@ -20914,12 +20914,12 @@ { "DuckDB": "461923a0d34defd0c726d6e5", "None": "461923a0d34defd0c726d6e5", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "461923a0d34defd0c726d6e5", "duckdb": "461923a0d34defd0c726d6e5", "generic": "461923a0d34defd0c726d6e5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "461923a0d34defd0c726d6e5", +"motherduck": "461923a0d34defd0c726d6e5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "461923a0d34defd0c726d6e5", "postgresql": "461923a0d34defd0c726d6e5", "snowflake": "461923a0d34defd0c726d6e5", @@ -20935,8 +20935,8 @@ "databricks": "dcbfb83ead5b0e32e500635b", "duckdb": "dcbfb83ead5b0e32e500635b", "generic": "dcbfb83ead5b0e32e500635b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "dcbfb83ead5b0e32e500635b", +"motherduck": "dcbfb83ead5b0e32e500635b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "dcbfb83ead5b0e32e500635b", "postgresql": "dcbfb83ead5b0e32e500635b", "snowflake": "dcbfb83ead5b0e32e500635b", @@ -20952,10 +20952,10 @@ "databricks": "a686bb6db17ab079cfc79224", "duckdb": "a686bb6db17ab079cfc79224", "generic": "a686bb6db17ab079cfc79224", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a686bb6db17ab079cfc79224", -"postgres": "a686bb6db17ab079cfc79224", -"postgresql": "a686bb6db17ab079cfc79224", +"motherduck": "a686bb6db17ab079cfc79224", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "74a30f6aa9def0b58afc616c", +"postgresql": "74a30f6aa9def0b58afc616c", "snowflake": "1096c3c8687c8e8eb538ff74", "tsql": "a686bb6db17ab079cfc79224" } @@ -20969,10 +20969,10 @@ "databricks": "e2879cf4770e7f48d2dd704a", "duckdb": "9d006c5299feb04426ce31ac", "generic": "e2879cf4770e7f48d2dd704a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2879cf4770e7f48d2dd704a", -"postgres": "e2879cf4770e7f48d2dd704a", -"postgresql": "e2879cf4770e7f48d2dd704a", +"motherduck": "9d006c5299feb04426ce31ac", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2d4aea8dec5521e258596f3d", +"postgresql": "2d4aea8dec5521e258596f3d", "snowflake": "97a20344d811fb77c7690863", "tsql": "e2879cf4770e7f48d2dd704a" } @@ -20982,14 +20982,14 @@ { "DuckDB": "d2c97d221599d038d9875873", "None": "d2c97d221599d038d9875873", -"bigquery": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", "databricks": "d2c97d221599d038d9875873", "duckdb": "d2c97d221599d038d9875873", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "d2c97d221599d038d9875873", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -21003,8 +21003,8 @@ "databricks": "013a8446f043affffcf194f8", "duckdb": "013a8446f043affffcf194f8", "generic": "013a8446f043affffcf194f8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "013a8446f043affffcf194f8", +"motherduck": "013a8446f043affffcf194f8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "013a8446f043affffcf194f8", "postgresql": "013a8446f043affffcf194f8", "snowflake": "97a20344d811fb77c7690863", @@ -21015,17 +21015,17 @@ "type", { "DuckDB": "a428302e4848ffe877284c84", -"None": "a428302e4848ffe877284c84", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "a428302e4848ffe877284c84", +"None": "c9b810639795a7bfab91b98d", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "c9b810639795a7bfab91b98d", "duckdb": "a428302e4848ffe877284c84", -"generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"generic": "c9b810639795a7bfab91b98d", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "a428302e4848ffe877284c84" +"tsql": "c9b810639795a7bfab91b98d" } ], [ @@ -21037,8 +21037,8 @@ "databricks": "8790273499dae4e6cbd2d034", "duckdb": "8790273499dae4e6cbd2d034", "generic": "8790273499dae4e6cbd2d034", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8790273499dae4e6cbd2d034", +"motherduck": "8790273499dae4e6cbd2d034", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8790273499dae4e6cbd2d034", "postgresql": "8790273499dae4e6cbd2d034", "snowflake": "9aff7fcc7d550e1a8d105471", @@ -21054,10 +21054,10 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "19e127c23b4598727a2d8ceb", "generic": "19e127c23b4598727a2d8ceb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aed0419e7f2ce7c0a8892248", -"postgres": "19e127c23b4598727a2d8ceb", -"postgresql": "19e127c23b4598727a2d8ceb", +"motherduck": "19e127c23b4598727a2d8ceb", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "111af35848fe500ec2ae54b2", +"postgresql": "111af35848fe500ec2ae54b2", "snowflake": "aed0419e7f2ce7c0a8892248", "tsql": "19e127c23b4598727a2d8ceb" } @@ -21071,8 +21071,8 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "b8321619b794db091c9e96a1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b8321619b794db091c9e96a1", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b8321619b794db091c9e96a1", "postgresql": "b8321619b794db091c9e96a1", "snowflake": "b8321619b794db091c9e96a1", @@ -21088,10 +21088,10 @@ "databricks": "bce60580ef3a1dc4ce569fff", "duckdb": "bce60580ef3a1dc4ce569fff", "generic": "bce60580ef3a1dc4ce569fff", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "bce60580ef3a1dc4ce569fff", -"postgres": "bce60580ef3a1dc4ce569fff", -"postgresql": "bce60580ef3a1dc4ce569fff", +"motherduck": "bce60580ef3a1dc4ce569fff", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eee236ea1427bdddbaf088ac", +"postgresql": "eee236ea1427bdddbaf088ac", "snowflake": "bce60580ef3a1dc4ce569fff", "tsql": "bce60580ef3a1dc4ce569fff" } @@ -21105,8 +21105,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "305aaf0b95cee629dd46380c", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "305aaf0b95cee629dd46380c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -21122,8 +21122,8 @@ "databricks": "73ed909ac0c80ba48ae6d17c", "duckdb": "73ed909ac0c80ba48ae6d17c", "generic": "73ed909ac0c80ba48ae6d17c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73ed909ac0c80ba48ae6d17c", +"motherduck": "73ed909ac0c80ba48ae6d17c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "73ed909ac0c80ba48ae6d17c", "postgresql": "73ed909ac0c80ba48ae6d17c", "snowflake": "73ed909ac0c80ba48ae6d17c", @@ -21133,14 +21133,14 @@ [ "type", { -"DuckDB": "c6654395c62d21b415299f72", +"DuckDB": "0712c33a016f7dd6a37ee011", "None": "c6654395c62d21b415299f72", "bigquery": "0712c33a016f7dd6a37ee011", "databricks": "c6654395c62d21b415299f72", -"duckdb": "c6654395c62d21b415299f72", +"duckdb": "0712c33a016f7dd6a37ee011", "generic": "c6654395c62d21b415299f72", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2978a8fe925c7f93c6e9fcfb", +"motherduck": "0712c33a016f7dd6a37ee011", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6654395c62d21b415299f72", "postgresql": "c6654395c62d21b415299f72", "snowflake": "0712c33a016f7dd6a37ee011", @@ -21156,8 +21156,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -21173,8 +21173,8 @@ "databricks": "5abf4ec799a2ec32fb10da7e", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5abf4ec799a2ec32fb10da7e", "postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -21190,8 +21190,8 @@ "databricks": "53100c87dc0e46dc31d2c6cc", "duckdb": "53100c87dc0e46dc31d2c6cc", "generic": "53100c87dc0e46dc31d2c6cc", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "53100c87dc0e46dc31d2c6cc", +"motherduck": "53100c87dc0e46dc31d2c6cc", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "53100c87dc0e46dc31d2c6cc", "postgresql": "53100c87dc0e46dc31d2c6cc", "snowflake": "53100c87dc0e46dc31d2c6cc", @@ -21207,8 +21207,8 @@ "databricks": "6992a9c8899f9fe5de26869c", "duckdb": "081a4ec9ca8c1ffbb8c41e4d", "generic": "6992a9c8899f9fe5de26869c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "081a4ec9ca8c1ffbb8c41e4d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "081a4ec9ca8c1ffbb8c41e4d", "postgresql": "081a4ec9ca8c1ffbb8c41e4d", "snowflake": "808e51c2deac58e29ecb851e", @@ -21224,8 +21224,8 @@ "databricks": "0c4610f182f18bf41d306e01", "duckdb": "0c4610f182f18bf41d306e01", "generic": "0c4610f182f18bf41d306e01", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0c4610f182f18bf41d306e01", +"motherduck": "0c4610f182f18bf41d306e01", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0c4610f182f18bf41d306e01", "postgresql": "0c4610f182f18bf41d306e01", "snowflake": "0c4610f182f18bf41d306e01", @@ -21241,8 +21241,8 @@ "databricks": "e068bc199d71601c823bb254", "duckdb": "e068bc199d71601c823bb254", "generic": "e068bc199d71601c823bb254", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e068bc199d71601c823bb254", +"motherduck": "e068bc199d71601c823bb254", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e068bc199d71601c823bb254", "postgresql": "e068bc199d71601c823bb254", "snowflake": "e068bc199d71601c823bb254", @@ -21258,10 +21258,10 @@ "databricks": "18036ada4276b0930d870788", "duckdb": "18036ada4276b0930d870788", "generic": "18036ada4276b0930d870788", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "18036ada4276b0930d870788", -"postgres": "18036ada4276b0930d870788", -"postgresql": "18036ada4276b0930d870788", +"motherduck": "18036ada4276b0930d870788", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "899d81b12a6c3aed6cf9dd53", +"postgresql": "899d81b12a6c3aed6cf9dd53", "snowflake": "18036ada4276b0930d870788", "tsql": "18036ada4276b0930d870788" } @@ -21275,8 +21275,8 @@ "databricks": "360298d6139a1e6f476862de", "duckdb": "3b86998e2968bafafb02d6c0", "generic": "2f6a1345f274f18462c576a9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "3b86998e2968bafafb02d6c0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3b86998e2968bafafb02d6c0", "postgresql": "3b86998e2968bafafb02d6c0", "snowflake": "f5272904633fd6945c70dc00", @@ -21292,8 +21292,8 @@ "databricks": "c6889f2965db73017be6f6e7", "duckdb": "c6889f2965db73017be6f6e7", "generic": "c6889f2965db73017be6f6e7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c6889f2965db73017be6f6e7", +"motherduck": "c6889f2965db73017be6f6e7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c6889f2965db73017be6f6e7", "postgresql": "c6889f2965db73017be6f6e7", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -21309,8 +21309,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -21326,8 +21326,8 @@ "databricks": "93fcb7d3c2979f1531daccf5", "duckdb": "93fcb7d3c2979f1531daccf5", "generic": "93fcb7d3c2979f1531daccf5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "93fcb7d3c2979f1531daccf5", +"motherduck": "93fcb7d3c2979f1531daccf5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "93fcb7d3c2979f1531daccf5", "postgresql": "93fcb7d3c2979f1531daccf5", "snowflake": "93fcb7d3c2979f1531daccf5", @@ -21343,8 +21343,8 @@ "databricks": "0475b57e9e9da81e87fa09ba", "duckdb": "0475b57e9e9da81e87fa09ba", "generic": "0475b57e9e9da81e87fa09ba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0475b57e9e9da81e87fa09ba", +"motherduck": "0475b57e9e9da81e87fa09ba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0475b57e9e9da81e87fa09ba", "postgresql": "0475b57e9e9da81e87fa09ba", "snowflake": "0475b57e9e9da81e87fa09ba", @@ -21360,8 +21360,8 @@ "databricks": "f35059f8984f0ac12ad1dc75", "duckdb": "f35059f8984f0ac12ad1dc75", "generic": "f35059f8984f0ac12ad1dc75", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f35059f8984f0ac12ad1dc75", +"motherduck": "f35059f8984f0ac12ad1dc75", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f35059f8984f0ac12ad1dc75", "postgresql": "f35059f8984f0ac12ad1dc75", "snowflake": "f35059f8984f0ac12ad1dc75", @@ -21377,8 +21377,8 @@ "databricks": "5aa51d84ac5e6c7a9306f348", "duckdb": "5aa51d84ac5e6c7a9306f348", "generic": "5aa51d84ac5e6c7a9306f348", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5aa51d84ac5e6c7a9306f348", +"motherduck": "5aa51d84ac5e6c7a9306f348", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5aa51d84ac5e6c7a9306f348", "postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "5aa51d84ac5e6c7a9306f348", @@ -21394,8 +21394,8 @@ "databricks": "3dbbe73ee4310c73030e8110", "duckdb": "3dbbe73ee4310c73030e8110", "generic": "3dbbe73ee4310c73030e8110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3dbbe73ee4310c73030e8110", +"motherduck": "3dbbe73ee4310c73030e8110", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3dbbe73ee4310c73030e8110", "postgresql": "3dbbe73ee4310c73030e8110", "snowflake": "f43dac38f34a1c0618a3f812", @@ -21411,8 +21411,8 @@ "databricks": "f43dac38f34a1c0618a3f812", "duckdb": "f43dac38f34a1c0618a3f812", "generic": "f43dac38f34a1c0618a3f812", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f43dac38f34a1c0618a3f812", +"motherduck": "f43dac38f34a1c0618a3f812", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f43dac38f34a1c0618a3f812", "postgresql": "f43dac38f34a1c0618a3f812", "snowflake": "f43dac38f34a1c0618a3f812", @@ -21428,8 +21428,8 @@ "databricks": "42a76d5ff05d0f91911ff368", "duckdb": "42a76d5ff05d0f91911ff368", "generic": "42a76d5ff05d0f91911ff368", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "42a76d5ff05d0f91911ff368", +"motherduck": "42a76d5ff05d0f91911ff368", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "42a76d5ff05d0f91911ff368", "postgresql": "42a76d5ff05d0f91911ff368", "snowflake": "42a76d5ff05d0f91911ff368", @@ -21441,14 +21441,14 @@ { "DuckDB": "7cd31289a5b99b5a5e24492d", "None": "7cd31289a5b99b5a5e24492d", -"bigquery": "7cd31289a5b99b5a5e24492d", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "7cd31289a5b99b5a5e24492d", "duckdb": "7cd31289a5b99b5a5e24492d", "generic": "7cd31289a5b99b5a5e24492d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7cd31289a5b99b5a5e24492d", -"postgres": "7cd31289a5b99b5a5e24492d", -"postgresql": "7cd31289a5b99b5a5e24492d", +"motherduck": "7cd31289a5b99b5a5e24492d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "c5bdaf88df7ef3d9ae693106", +"postgresql": "c5bdaf88df7ef3d9ae693106", "snowflake": "7cd31289a5b99b5a5e24492d", "tsql": "7cd31289a5b99b5a5e24492d" } @@ -21458,12 +21458,12 @@ { "DuckDB": "cbd04e906c540e91d7c8ea88", "None": "cbd04e906c540e91d7c8ea88", -"bigquery": "b5c4d5044b2a6e70633f0d0a", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "cbd04e906c540e91d7c8ea88", "duckdb": "cbd04e906c540e91d7c8ea88", "generic": "cbd04e906c540e91d7c8ea88", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cbd04e906c540e91d7c8ea88", +"motherduck": "cbd04e906c540e91d7c8ea88", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cbd04e906c540e91d7c8ea88", "postgresql": "cbd04e906c540e91d7c8ea88", "snowflake": "cbd04e906c540e91d7c8ea88", @@ -21479,8 +21479,8 @@ "databricks": "7177019d5faf5b3046623257", "duckdb": "7177019d5faf5b3046623257", "generic": "7177019d5faf5b3046623257", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7177019d5faf5b3046623257", +"motherduck": "7177019d5faf5b3046623257", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7177019d5faf5b3046623257", "postgresql": "7177019d5faf5b3046623257", "snowflake": "7177019d5faf5b3046623257", @@ -21496,8 +21496,8 @@ "databricks": "277693b7c19b2696f01403ba", "duckdb": "277693b7c19b2696f01403ba", "generic": "277693b7c19b2696f01403ba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "277693b7c19b2696f01403ba", +"motherduck": "277693b7c19b2696f01403ba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "277693b7c19b2696f01403ba", "postgresql": "277693b7c19b2696f01403ba", "snowflake": "277693b7c19b2696f01403ba", @@ -21513,8 +21513,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -21530,8 +21530,8 @@ "databricks": "1bdf5908ca249b2331a0427c", "duckdb": "1bdf5908ca249b2331a0427c", "generic": "1bdf5908ca249b2331a0427c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1bdf5908ca249b2331a0427c", +"motherduck": "1bdf5908ca249b2331a0427c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1bdf5908ca249b2331a0427c", "postgresql": "1bdf5908ca249b2331a0427c", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -21547,8 +21547,8 @@ "databricks": "e1c74d96ac578f9323bf1bbd", "duckdb": "e1c74d96ac578f9323bf1bbd", "generic": "e1c74d96ac578f9323bf1bbd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e1c74d96ac578f9323bf1bbd", +"motherduck": "e1c74d96ac578f9323bf1bbd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e1c74d96ac578f9323bf1bbd", "postgresql": "e1c74d96ac578f9323bf1bbd", "snowflake": "e1c74d96ac578f9323bf1bbd", @@ -21564,8 +21564,8 @@ "databricks": "cafb5cff5526dd419baad0ed", "duckdb": "cafb5cff5526dd419baad0ed", "generic": "cafb5cff5526dd419baad0ed", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cafb5cff5526dd419baad0ed", +"motherduck": "cafb5cff5526dd419baad0ed", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cafb5cff5526dd419baad0ed", "postgresql": "cafb5cff5526dd419baad0ed", "snowflake": "cafb5cff5526dd419baad0ed", @@ -21581,8 +21581,8 @@ "databricks": "e8b6e0bd2ded7b9eec6209e4", "duckdb": "e8b6e0bd2ded7b9eec6209e4", "generic": "e8b6e0bd2ded7b9eec6209e4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e8b6e0bd2ded7b9eec6209e4", +"motherduck": "e8b6e0bd2ded7b9eec6209e4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8b6e0bd2ded7b9eec6209e4", "postgresql": "e8b6e0bd2ded7b9eec6209e4", "snowflake": "e8b6e0bd2ded7b9eec6209e4", @@ -21598,8 +21598,8 @@ "databricks": "b2c9b6ebca6c097f3caa0aa8", "duckdb": "b2c9b6ebca6c097f3caa0aa8", "generic": "b2c9b6ebca6c097f3caa0aa8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b2c9b6ebca6c097f3caa0aa8", +"motherduck": "b2c9b6ebca6c097f3caa0aa8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b2c9b6ebca6c097f3caa0aa8", "postgresql": "b2c9b6ebca6c097f3caa0aa8", "snowflake": "b2c9b6ebca6c097f3caa0aa8", @@ -21611,14 +21611,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -21628,12 +21628,12 @@ { "DuckDB": "18db5afe2c1e80d1ee652b54", "None": "18db5afe2c1e80d1ee652b54", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "18db5afe2c1e80d1ee652b54", "duckdb": "18db5afe2c1e80d1ee652b54", "generic": "18db5afe2c1e80d1ee652b54", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "18db5afe2c1e80d1ee652b54", +"motherduck": "18db5afe2c1e80d1ee652b54", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "18db5afe2c1e80d1ee652b54", "postgresql": "18db5afe2c1e80d1ee652b54", "snowflake": "18db5afe2c1e80d1ee652b54", @@ -21649,8 +21649,8 @@ "databricks": "5524945ebcb15c363d317b3c", "duckdb": "219314eaf94cabfe1c7e559c", "generic": "4aab4bdd20039d5e16058b1b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5524945ebcb15c363d317b3c", +"motherduck": "219314eaf94cabfe1c7e559c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "219314eaf94cabfe1c7e559c", "postgresql": "219314eaf94cabfe1c7e559c", "snowflake": "b767a0334d4c0090a22665f5", @@ -21666,8 +21666,8 @@ "databricks": "84e86bec7646b6ad19ceef59", "duckdb": "6a2162b5abe5a73734c47041", "generic": "6a2162b5abe5a73734c47041", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6a2162b5abe5a73734c47041", +"motherduck": "6a2162b5abe5a73734c47041", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6a2162b5abe5a73734c47041", "postgresql": "6a2162b5abe5a73734c47041", "snowflake": "16d902e899040d0c0c9dcf58", @@ -21683,8 +21683,8 @@ "databricks": "8790273499dae4e6cbd2d034", "duckdb": "8790273499dae4e6cbd2d034", "generic": "8790273499dae4e6cbd2d034", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8790273499dae4e6cbd2d034", +"motherduck": "8790273499dae4e6cbd2d034", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8790273499dae4e6cbd2d034", "postgresql": "8790273499dae4e6cbd2d034", "snowflake": "9aff7fcc7d550e1a8d105471", @@ -21700,10 +21700,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -21717,8 +21717,8 @@ "databricks": "77298ddff3580b41e361ba6d", "duckdb": "bf74994a132713cd5a93b70b", "generic": "74d4939af66c472f17ecfa08", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ce873d09a353281e316461aa", +"motherduck": "bf74994a132713cd5a93b70b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cf182821f911fadedb1f868d", "postgresql": "cf182821f911fadedb1f868d", "snowflake": "5c5b258591d9f7cb305a4220", @@ -21734,8 +21734,8 @@ "databricks": "b66ef401bfc62ea5f67697f0", "duckdb": "b66ef401bfc62ea5f67697f0", "generic": "b66ef401bfc62ea5f67697f0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b66ef401bfc62ea5f67697f0", +"motherduck": "b66ef401bfc62ea5f67697f0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b66ef401bfc62ea5f67697f0", "postgresql": "b66ef401bfc62ea5f67697f0", "snowflake": "b66ef401bfc62ea5f67697f0", @@ -21747,12 +21747,12 @@ { "DuckDB": "8203bd5901a8ec71ff7c103e", "None": "8203bd5901a8ec71ff7c103e", -"bigquery": "2a0918be53051fe629d9ff8f", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "8203bd5901a8ec71ff7c103e", "duckdb": "8203bd5901a8ec71ff7c103e", "generic": "8203bd5901a8ec71ff7c103e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8203bd5901a8ec71ff7c103e", +"motherduck": "8203bd5901a8ec71ff7c103e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8203bd5901a8ec71ff7c103e", "postgresql": "8203bd5901a8ec71ff7c103e", "snowflake": "8203bd5901a8ec71ff7c103e", @@ -21764,14 +21764,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -21781,12 +21781,12 @@ { "DuckDB": "6199046833cb1b5de6e50c1f", "None": "6199046833cb1b5de6e50c1f", -"bigquery": "6199046833cb1b5de6e50c1f", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "6199046833cb1b5de6e50c1f", "duckdb": "6199046833cb1b5de6e50c1f", "generic": "6199046833cb1b5de6e50c1f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6199046833cb1b5de6e50c1f", +"motherduck": "6199046833cb1b5de6e50c1f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6199046833cb1b5de6e50c1f", "postgresql": "6199046833cb1b5de6e50c1f", "snowflake": "6199046833cb1b5de6e50c1f", @@ -21798,12 +21798,12 @@ { "DuckDB": "f1158467f7ab7b47d7e993d0", "None": "f1158467f7ab7b47d7e993d0", -"bigquery": "f1158467f7ab7b47d7e993d0", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "f1158467f7ab7b47d7e993d0", "duckdb": "f1158467f7ab7b47d7e993d0", "generic": "f1158467f7ab7b47d7e993d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f1158467f7ab7b47d7e993d0", +"motherduck": "f1158467f7ab7b47d7e993d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f1158467f7ab7b47d7e993d0", "postgresql": "f1158467f7ab7b47d7e993d0", "snowflake": "f1158467f7ab7b47d7e993d0", @@ -21814,17 +21814,17 @@ "type", { "DuckDB": "23f70cb2333740d79361d52e", -"None": "23f70cb2333740d79361d52e", -"bigquery": "816384049477221b0a4a5b89", -"databricks": "23f70cb2333740d79361d52e", +"None": "a33d60d9b009878ab623c1d8", +"bigquery": "bb92c01c64d1a2d32abb67b5", +"databricks": "a33d60d9b009878ab623c1d8", "duckdb": "23f70cb2333740d79361d52e", -"generic": "23f70cb2333740d79361d52e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "23f70cb2333740d79361d52e", -"postgres": "23f70cb2333740d79361d52e", -"postgresql": "23f70cb2333740d79361d52e", +"generic": "a33d60d9b009878ab623c1d8", +"motherduck": "23f70cb2333740d79361d52e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f276e907770196606577c932", +"postgresql": "f276e907770196606577c932", "snowflake": "23f70cb2333740d79361d52e", -"tsql": "23f70cb2333740d79361d52e" +"tsql": "a33d60d9b009878ab623c1d8" } ], [ @@ -21836,8 +21836,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -21853,10 +21853,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -21870,8 +21870,8 @@ "databricks": "527932781ba4bab32cb5e881", "duckdb": "527932781ba4bab32cb5e881", "generic": "527932781ba4bab32cb5e881", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "527932781ba4bab32cb5e881", +"motherduck": "527932781ba4bab32cb5e881", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "527932781ba4bab32cb5e881", "postgresql": "527932781ba4bab32cb5e881", "snowflake": "527932781ba4bab32cb5e881", @@ -21883,12 +21883,12 @@ { "DuckDB": "623dbde002b57284f477b0b5", "None": "623dbde002b57284f477b0b5", -"bigquery": "623dbde002b57284f477b0b5", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "623dbde002b57284f477b0b5", "duckdb": "623dbde002b57284f477b0b5", "generic": "623dbde002b57284f477b0b5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "623dbde002b57284f477b0b5", +"motherduck": "623dbde002b57284f477b0b5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "623dbde002b57284f477b0b5", "postgresql": "623dbde002b57284f477b0b5", "snowflake": "623dbde002b57284f477b0b5", @@ -21904,8 +21904,8 @@ "databricks": "a12a2ad8c11bbf6a41794d33", "duckdb": "a12a2ad8c11bbf6a41794d33", "generic": "a12a2ad8c11bbf6a41794d33", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a12a2ad8c11bbf6a41794d33", +"motherduck": "a12a2ad8c11bbf6a41794d33", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a12a2ad8c11bbf6a41794d33", "postgresql": "a12a2ad8c11bbf6a41794d33", "snowflake": "a12a2ad8c11bbf6a41794d33", @@ -21917,12 +21917,12 @@ { "DuckDB": "558da38ec4d9d5d6c72f60cf", "None": "558da38ec4d9d5d6c72f60cf", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "558da38ec4d9d5d6c72f60cf", "duckdb": "558da38ec4d9d5d6c72f60cf", "generic": "558da38ec4d9d5d6c72f60cf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "558da38ec4d9d5d6c72f60cf", +"motherduck": "558da38ec4d9d5d6c72f60cf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "558da38ec4d9d5d6c72f60cf", "postgresql": "558da38ec4d9d5d6c72f60cf", "snowflake": "558da38ec4d9d5d6c72f60cf", @@ -21933,17 +21933,17 @@ "type", { "DuckDB": "363159f251e264604338e690", -"None": "363159f251e264604338e690", -"bigquery": "363159f251e264604338e690", -"databricks": "363159f251e264604338e690", +"None": "9a63ad6168418af23d9b6fd1", +"bigquery": "8b8d5f75ba6dec68b4cebc6b", +"databricks": "9a63ad6168418af23d9b6fd1", "duckdb": "363159f251e264604338e690", -"generic": "363159f251e264604338e690", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "363159f251e264604338e690", -"postgres": "363159f251e264604338e690", -"postgresql": "363159f251e264604338e690", +"generic": "9a63ad6168418af23d9b6fd1", +"motherduck": "363159f251e264604338e690", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f276e907770196606577c932", +"postgresql": "f276e907770196606577c932", "snowflake": "363159f251e264604338e690", -"tsql": "363159f251e264604338e690" +"tsql": "9a63ad6168418af23d9b6fd1" } ], [ @@ -21952,11 +21952,11 @@ "DuckDB": "b6200c25bc3749f5724d237c", "None": "b6200c25bc3749f5724d237c", "bigquery": "b6200c25bc3749f5724d237c", -"databricks": "6b1db1e2f94caeb40dbea19b", +"databricks": "b6200c25bc3749f5724d237c", "duckdb": "b6200c25bc3749f5724d237c", "generic": "b6200c25bc3749f5724d237c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "b6200c25bc3749f5724d237c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b6200c25bc3749f5724d237c", "postgresql": "b6200c25bc3749f5724d237c", "snowflake": "b6200c25bc3749f5724d237c", @@ -21972,8 +21972,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -21989,8 +21989,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -22001,32 +22001,32 @@ "type", { "DuckDB": "129cd0245509c52e0d7ac815", -"None": "8d1119d9033bc544ced02739", -"bigquery": "ef3ab21b1ec5acc43562f6e2", -"databricks": "5b41dbff68938ce2e8a5c35d", +"None": "1071df52a9e8350ac0c2cd33", +"bigquery": "1071df52a9e8350ac0c2cd33", +"databricks": "1071df52a9e8350ac0c2cd33", "duckdb": "129cd0245509c52e0d7ac815", -"generic": "8d1119d9033bc544ced02739", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b9f1a78bcda3bc968346cc10", -"postgres": "129cd0245509c52e0d7ac815", -"postgresql": "129cd0245509c52e0d7ac815", +"generic": "1071df52a9e8350ac0c2cd33", +"motherduck": "129cd0245509c52e0d7ac815", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "1071df52a9e8350ac0c2cd33", +"postgresql": "1071df52a9e8350ac0c2cd33", "snowflake": "24b68111659c8d395da7df6a", -"tsql": "e42dc1c3607e8e3b3c865c3f" +"tsql": "1071df52a9e8350ac0c2cd33" } ], [ "type", { -"DuckDB": "60bd7daa04bed898e52118ab", -"None": "070c0836fb3402c924b00b0e", +"DuckDB": "3d2b3b1097973d173f205074", +"None": "3aac0f59706540c7a59cbce4", "bigquery": "3aac0f59706540c7a59cbce4", -"databricks": "070c0836fb3402c924b00b0e", -"duckdb": "60bd7daa04bed898e52118ab", -"generic": "070c0836fb3402c924b00b0e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "60bd7daa04bed898e52118ab", -"postgresql": "60bd7daa04bed898e52118ab", +"databricks": "3aac0f59706540c7a59cbce4", +"duckdb": "3d2b3b1097973d173f205074", +"generic": "3aac0f59706540c7a59cbce4", +"motherduck": "3d2b3b1097973d173f205074", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3d2b3b1097973d173f205074", +"postgresql": "3d2b3b1097973d173f205074", "snowflake": "0a5fcaec13e26e3caacd5345", "tsql": "33f30462ac4f41af4b28bd1a" } @@ -22040,8 +22040,8 @@ "databricks": "94006e4eb73bd1f728de7a83", "duckdb": "2f6203391b0efaaf0a3c9d00", "generic": "2f6203391b0efaaf0a3c9d00", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2f6203391b0efaaf0a3c9d00", +"motherduck": "2f6203391b0efaaf0a3c9d00", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2f6203391b0efaaf0a3c9d00", "postgresql": "2f6203391b0efaaf0a3c9d00", "snowflake": "dc61037c72b2e7b4730d26cc", @@ -22057,8 +22057,8 @@ "databricks": "6a534f7a641457b40e35d984", "duckdb": "6a534f7a641457b40e35d984", "generic": "6a534f7a641457b40e35d984", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6a534f7a641457b40e35d984", +"motherduck": "6a534f7a641457b40e35d984", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6a534f7a641457b40e35d984", "postgresql": "6a534f7a641457b40e35d984", "snowflake": "6a534f7a641457b40e35d984", @@ -22070,14 +22070,14 @@ { "DuckDB": "60b39a68a18438603dd5496d", "None": "60b39a68a18438603dd5496d", -"bigquery": "60b39a68a18438603dd5496d", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "60b39a68a18438603dd5496d", "duckdb": "60b39a68a18438603dd5496d", "generic": "60b39a68a18438603dd5496d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "60b39a68a18438603dd5496d", -"postgres": "60b39a68a18438603dd5496d", -"postgresql": "60b39a68a18438603dd5496d", +"motherduck": "60b39a68a18438603dd5496d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "7a007e6ff9e9465c9d7fadea", +"postgresql": "7a007e6ff9e9465c9d7fadea", "snowflake": "60b39a68a18438603dd5496d", "tsql": "60b39a68a18438603dd5496d" } @@ -22091,8 +22091,8 @@ "databricks": "126765943545b2608ebe7128", "duckdb": "126765943545b2608ebe7128", "generic": "126765943545b2608ebe7128", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "126765943545b2608ebe7128", +"motherduck": "126765943545b2608ebe7128", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "126765943545b2608ebe7128", "postgresql": "126765943545b2608ebe7128", "snowflake": "126765943545b2608ebe7128", @@ -22108,8 +22108,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -22122,11 +22122,11 @@ "DuckDB": "9c2cff8be7225cf79883ca65", "None": "9c2cff8be7225cf79883ca65", "bigquery": "9c2cff8be7225cf79883ca65", -"databricks": "901ac89f8d9ec18bd3a61e4b", +"databricks": "9c2cff8be7225cf79883ca65", "duckdb": "9c2cff8be7225cf79883ca65", "generic": "9c2cff8be7225cf79883ca65", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "901ac89f8d9ec18bd3a61e4b", +"motherduck": "9c2cff8be7225cf79883ca65", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9c2cff8be7225cf79883ca65", "postgresql": "9c2cff8be7225cf79883ca65", "snowflake": "9c2cff8be7225cf79883ca65", @@ -22142,8 +22142,8 @@ "databricks": "cf05d378f282d0abe941a82f", "duckdb": "cf05d378f282d0abe941a82f", "generic": "cf05d378f282d0abe941a82f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cf05d378f282d0abe941a82f", +"motherduck": "cf05d378f282d0abe941a82f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cf05d378f282d0abe941a82f", "postgresql": "cf05d378f282d0abe941a82f", "snowflake": "cf05d378f282d0abe941a82f", @@ -22159,10 +22159,10 @@ "databricks": "4b356542044f1267fcfc487a", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "4b356542044f1267fcfc487a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4b356542044f1267fcfc487a", -"postgres": "4b356542044f1267fcfc487a", -"postgresql": "4b356542044f1267fcfc487a", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a5656d70e208254d1d3e9b4f", +"postgresql": "a5656d70e208254d1d3e9b4f", "snowflake": "4b356542044f1267fcfc487a", "tsql": "4b356542044f1267fcfc487a" } @@ -22176,8 +22176,8 @@ "databricks": "d7b74701deb8b87c32deb7a6", "duckdb": "d7b74701deb8b87c32deb7a6", "generic": "d7b74701deb8b87c32deb7a6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d7b74701deb8b87c32deb7a6", +"motherduck": "d7b74701deb8b87c32deb7a6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d7b74701deb8b87c32deb7a6", "postgresql": "d7b74701deb8b87c32deb7a6", "snowflake": "d7b74701deb8b87c32deb7a6", @@ -22193,8 +22193,8 @@ "databricks": "078c0e4b25cdb89eb4ebd88f", "duckdb": "078c0e4b25cdb89eb4ebd88f", "generic": "078c0e4b25cdb89eb4ebd88f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "078c0e4b25cdb89eb4ebd88f", +"motherduck": "078c0e4b25cdb89eb4ebd88f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "078c0e4b25cdb89eb4ebd88f", "postgresql": "078c0e4b25cdb89eb4ebd88f", "snowflake": "6306b9e88f7b13dbb6a32c00", @@ -22206,14 +22206,14 @@ { "DuckDB": "e46d4be44ab9e500e9190d26", "None": "e46d4be44ab9e500e9190d26", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "e46d4be44ab9e500e9190d26", "duckdb": "e46d4be44ab9e500e9190d26", "generic": "e46d4be44ab9e500e9190d26", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e46d4be44ab9e500e9190d26", -"postgres": "e46d4be44ab9e500e9190d26", -"postgresql": "e46d4be44ab9e500e9190d26", +"motherduck": "e46d4be44ab9e500e9190d26", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "251aba3fef503ce64556c701", +"postgresql": "251aba3fef503ce64556c701", "snowflake": "e46d4be44ab9e500e9190d26", "tsql": "e46d4be44ab9e500e9190d26" } @@ -22222,17 +22222,17 @@ "type", { "DuckDB": "dcd0570bcd1ca6e7cbe9b206", -"None": "dcd0570bcd1ca6e7cbe9b206", -"bigquery": "3b4c01f94cca3bf195a3fd00", -"databricks": "526d6b30a5f27d05c0a26aa0", +"None": "85a8004226c2b77c6b697bab", +"bigquery": "85a8004226c2b77c6b697bab", +"databricks": "85a8004226c2b77c6b697bab", "duckdb": "dcd0570bcd1ca6e7cbe9b206", -"generic": "dcd0570bcd1ca6e7cbe9b206", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a5a929e25b7d0dae21e9bb65", -"postgres": "dcd0570bcd1ca6e7cbe9b206", -"postgresql": "dcd0570bcd1ca6e7cbe9b206", +"generic": "85a8004226c2b77c6b697bab", +"motherduck": "dcd0570bcd1ca6e7cbe9b206", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "85a8004226c2b77c6b697bab", +"postgresql": "85a8004226c2b77c6b697bab", "snowflake": "339dae99bd73c126e700c594", -"tsql": "dcd0570bcd1ca6e7cbe9b206" +"tsql": "85a8004226c2b77c6b697bab" } ], [ @@ -22244,8 +22244,8 @@ "databricks": "00402a032fb29ce84ecc4615", "duckdb": "00402a032fb29ce84ecc4615", "generic": "00402a032fb29ce84ecc4615", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "00402a032fb29ce84ecc4615", +"motherduck": "00402a032fb29ce84ecc4615", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "00402a032fb29ce84ecc4615", "postgresql": "00402a032fb29ce84ecc4615", "snowflake": "00402a032fb29ce84ecc4615", @@ -22261,8 +22261,8 @@ "databricks": "52921fa22fa8a5b698ef368f", "duckdb": "52921fa22fa8a5b698ef368f", "generic": "52921fa22fa8a5b698ef368f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "52921fa22fa8a5b698ef368f", +"motherduck": "52921fa22fa8a5b698ef368f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "52921fa22fa8a5b698ef368f", "postgresql": "52921fa22fa8a5b698ef368f", "snowflake": "52921fa22fa8a5b698ef368f", @@ -22278,8 +22278,8 @@ "databricks": "4fb572024031cb7631777be1", "duckdb": "4114b18e7e26d16613331fa7", "generic": "4114b18e7e26d16613331fa7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4114b18e7e26d16613331fa7", +"motherduck": "4114b18e7e26d16613331fa7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4114b18e7e26d16613331fa7", "postgresql": "4114b18e7e26d16613331fa7", "snowflake": "4114b18e7e26d16613331fa7", @@ -22295,8 +22295,8 @@ "databricks": "5aa51d84ac5e6c7a9306f348", "duckdb": "5aa51d84ac5e6c7a9306f348", "generic": "5aa51d84ac5e6c7a9306f348", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5aa51d84ac5e6c7a9306f348", +"motherduck": "5aa51d84ac5e6c7a9306f348", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5aa51d84ac5e6c7a9306f348", "postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "5aa51d84ac5e6c7a9306f348", @@ -22312,8 +22312,8 @@ "databricks": "58f6dfd7cabdc84b33dc2a96", "duckdb": "630c8b82ec44c7208a6df405", "generic": "fa5c71c0d2354f76510bf3e7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "58f6dfd7cabdc84b33dc2a96", +"motherduck": "630c8b82ec44c7208a6df405", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "630c8b82ec44c7208a6df405", "postgresql": "630c8b82ec44c7208a6df405", "snowflake": "8efe0c6c8c4444b8fe68129b", @@ -22325,14 +22325,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -22346,8 +22346,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -22359,14 +22359,14 @@ { "DuckDB": "dbd808c57538b7d212ed9a7c", "None": "dbd808c57538b7d212ed9a7c", -"bigquery": "dbd808c57538b7d212ed9a7c", +"bigquery": "c74425c5ce650ac69c83ca5b", "databricks": "dbd808c57538b7d212ed9a7c", "duckdb": "dbd808c57538b7d212ed9a7c", "generic": "dbd808c57538b7d212ed9a7c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "dbd808c57538b7d212ed9a7c", -"postgres": "dbd808c57538b7d212ed9a7c", -"postgresql": "dbd808c57538b7d212ed9a7c", +"motherduck": "dbd808c57538b7d212ed9a7c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "932963c69958d2a639768fd3", +"postgresql": "932963c69958d2a639768fd3", "snowflake": "dbd808c57538b7d212ed9a7c", "tsql": "dbd808c57538b7d212ed9a7c" } @@ -22380,8 +22380,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -22397,8 +22397,8 @@ "databricks": "79278352c17c9de0f5a28af5", "duckdb": "79278352c17c9de0f5a28af5", "generic": "79278352c17c9de0f5a28af5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "79278352c17c9de0f5a28af5", +"motherduck": "79278352c17c9de0f5a28af5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "79278352c17c9de0f5a28af5", "postgresql": "79278352c17c9de0f5a28af5", "snowflake": "97a20344d811fb77c7690863", @@ -22414,8 +22414,8 @@ "databricks": "bbc7d9037d6f0383eb14d7eb", "duckdb": "bbc7d9037d6f0383eb14d7eb", "generic": "bbc7d9037d6f0383eb14d7eb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "bbc7d9037d6f0383eb14d7eb", +"motherduck": "bbc7d9037d6f0383eb14d7eb", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "bbc7d9037d6f0383eb14d7eb", "postgresql": "bbc7d9037d6f0383eb14d7eb", "snowflake": "bbc7d9037d6f0383eb14d7eb", @@ -22427,14 +22427,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -22448,8 +22448,8 @@ "databricks": "cb06a5553de70a4924ed6600", "duckdb": "cb06a5553de70a4924ed6600", "generic": "cb06a5553de70a4924ed6600", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cb06a5553de70a4924ed6600", +"motherduck": "cb06a5553de70a4924ed6600", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cb06a5553de70a4924ed6600", "postgresql": "cb06a5553de70a4924ed6600", "snowflake": "cb06a5553de70a4924ed6600", @@ -22461,14 +22461,14 @@ { "DuckDB": "38b2ec94bf02be40007ce525", "None": "38b2ec94bf02be40007ce525", -"bigquery": "38b2ec94bf02be40007ce525", +"bigquery": "850deea990b52b82b36a9848", "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", -"postgres": "38b2ec94bf02be40007ce525", -"postgresql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "850deea990b52b82b36a9848", +"postgresql": "850deea990b52b82b36a9848", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "38b2ec94bf02be40007ce525" } @@ -22478,14 +22478,14 @@ { "DuckDB": "7cd31289a5b99b5a5e24492d", "None": "7cd31289a5b99b5a5e24492d", -"bigquery": "7cd31289a5b99b5a5e24492d", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "7cd31289a5b99b5a5e24492d", "duckdb": "7cd31289a5b99b5a5e24492d", "generic": "7cd31289a5b99b5a5e24492d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7cd31289a5b99b5a5e24492d", -"postgres": "7cd31289a5b99b5a5e24492d", -"postgresql": "7cd31289a5b99b5a5e24492d", +"motherduck": "7cd31289a5b99b5a5e24492d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "c5bdaf88df7ef3d9ae693106", +"postgresql": "c5bdaf88df7ef3d9ae693106", "snowflake": "7cd31289a5b99b5a5e24492d", "tsql": "7cd31289a5b99b5a5e24492d" } @@ -22499,8 +22499,8 @@ "databricks": "4e7908098c87141abb62306c", "duckdb": "1eb7826ddab37fc01598a8e9", "generic": "4e7908098c87141abb62306c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "1eb7826ddab37fc01598a8e9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8ca050e9a43027521099ab95", "postgresql": "8ca050e9a43027521099ab95", "snowflake": "92f647d5460e4e2e7e25fb6d", @@ -22516,8 +22516,8 @@ "databricks": "a0131c4099eb4915760bab4a", "duckdb": "a0131c4099eb4915760bab4a", "generic": "a0131c4099eb4915760bab4a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a0131c4099eb4915760bab4a", +"motherduck": "a0131c4099eb4915760bab4a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a0131c4099eb4915760bab4a", "postgresql": "a0131c4099eb4915760bab4a", "snowflake": "a0131c4099eb4915760bab4a", @@ -22529,14 +22529,14 @@ { "DuckDB": "b561884132dbe7e42b719110", "None": "b561884132dbe7e42b719110", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "b561884132dbe7e42b719110", "duckdb": "b561884132dbe7e42b719110", "generic": "b561884132dbe7e42b719110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b561884132dbe7e42b719110", -"postgres": "b561884132dbe7e42b719110", -"postgresql": "b561884132dbe7e42b719110", +"motherduck": "b561884132dbe7e42b719110", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5aa51d84ac5e6c7a9306f348", +"postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "b561884132dbe7e42b719110", "tsql": "b561884132dbe7e42b719110" } @@ -22550,10 +22550,10 @@ "databricks": "de89632e277dbc8c97115419", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -22567,8 +22567,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -22584,8 +22584,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -22601,8 +22601,8 @@ "databricks": "86b7927f577e56d61eb9f879", "duckdb": "86b7927f577e56d61eb9f879", "generic": "86b7927f577e56d61eb9f879", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "86b7927f577e56d61eb9f879", +"motherduck": "86b7927f577e56d61eb9f879", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "86b7927f577e56d61eb9f879", "postgresql": "86b7927f577e56d61eb9f879", "snowflake": "86b7927f577e56d61eb9f879", @@ -22618,8 +22618,8 @@ "databricks": "c82815abe30b3d099903f838", "duckdb": "c82815abe30b3d099903f838", "generic": "c82815abe30b3d099903f838", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c82815abe30b3d099903f838", +"motherduck": "c82815abe30b3d099903f838", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c82815abe30b3d099903f838", "postgresql": "c82815abe30b3d099903f838", "snowflake": "c82815abe30b3d099903f838", @@ -22635,8 +22635,8 @@ "databricks": "7d23077fb72f7bac9a49a632", "duckdb": "7d23077fb72f7bac9a49a632", "generic": "7d23077fb72f7bac9a49a632", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7d23077fb72f7bac9a49a632", +"motherduck": "7d23077fb72f7bac9a49a632", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7d23077fb72f7bac9a49a632", "postgresql": "7d23077fb72f7bac9a49a632", "snowflake": "7d23077fb72f7bac9a49a632", @@ -22652,10 +22652,10 @@ "databricks": "177c462b3a0270e894c8111c", "duckdb": "177c462b3a0270e894c8111c", "generic": "177c462b3a0270e894c8111c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "177c462b3a0270e894c8111c", -"postgres": "177c462b3a0270e894c8111c", -"postgresql": "177c462b3a0270e894c8111c", +"motherduck": "177c462b3a0270e894c8111c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "2625125fd986796ed33a61b7", +"postgresql": "2625125fd986796ed33a61b7", "snowflake": "177c462b3a0270e894c8111c", "tsql": "177c462b3a0270e894c8111c" } @@ -22669,8 +22669,8 @@ "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fe23594c781e79cbb0c8927a", "postgresql": "fe23594c781e79cbb0c8927a", "snowflake": "38b2ec94bf02be40007ce525", @@ -22682,14 +22682,14 @@ { "DuckDB": "08736485547ba339930697e9", "None": "08736485547ba339930697e9", -"bigquery": "08736485547ba339930697e9", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "08736485547ba339930697e9", "duckdb": "08736485547ba339930697e9", "generic": "08736485547ba339930697e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "08736485547ba339930697e9", -"postgres": "08736485547ba339930697e9", -"postgresql": "08736485547ba339930697e9", +"motherduck": "08736485547ba339930697e9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eecd452b4f5f3f4133d0bd0a", +"postgresql": "eecd452b4f5f3f4133d0bd0a", "snowflake": "08736485547ba339930697e9", "tsql": "08736485547ba339930697e9" } @@ -22703,8 +22703,8 @@ "databricks": "8d81e8dacd544a5e07c3b1ea", "duckdb": "8d81e8dacd544a5e07c3b1ea", "generic": "8d81e8dacd544a5e07c3b1ea", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8d81e8dacd544a5e07c3b1ea", +"motherduck": "8d81e8dacd544a5e07c3b1ea", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8d81e8dacd544a5e07c3b1ea", "postgresql": "8d81e8dacd544a5e07c3b1ea", "snowflake": "8d81e8dacd544a5e07c3b1ea", @@ -22720,10 +22720,10 @@ "databricks": "3e611643f0beab4953c4e09b", "duckdb": "3e611643f0beab4953c4e09b", "generic": "3e611643f0beab4953c4e09b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3e611643f0beab4953c4e09b", -"postgres": "3e611643f0beab4953c4e09b", -"postgresql": "3e611643f0beab4953c4e09b", +"motherduck": "3e611643f0beab4953c4e09b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "cae477ce59c72869f37a9a40", +"postgresql": "cae477ce59c72869f37a9a40", "snowflake": "3e611643f0beab4953c4e09b", "tsql": "3e611643f0beab4953c4e09b" } @@ -22737,8 +22737,8 @@ "databricks": "e2eee356d05f550b28bf85ad", "duckdb": "e2eee356d05f550b28bf85ad", "generic": "e2eee356d05f550b28bf85ad", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e2eee356d05f550b28bf85ad", +"motherduck": "e2eee356d05f550b28bf85ad", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e2eee356d05f550b28bf85ad", "postgresql": "e2eee356d05f550b28bf85ad", "snowflake": "e2eee356d05f550b28bf85ad", @@ -22754,10 +22754,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -22771,8 +22771,8 @@ "databricks": "3dbbe73ee4310c73030e8110", "duckdb": "3dbbe73ee4310c73030e8110", "generic": "3dbbe73ee4310c73030e8110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3dbbe73ee4310c73030e8110", +"motherduck": "3dbbe73ee4310c73030e8110", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3dbbe73ee4310c73030e8110", "postgresql": "3dbbe73ee4310c73030e8110", "snowflake": "f43dac38f34a1c0618a3f812", @@ -22788,8 +22788,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -22805,8 +22805,8 @@ "databricks": "6ebf45a787a223241c8d9a47", "duckdb": "6ebf45a787a223241c8d9a47", "generic": "6ebf45a787a223241c8d9a47", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6ebf45a787a223241c8d9a47", +"motherduck": "6ebf45a787a223241c8d9a47", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6ebf45a787a223241c8d9a47", "postgresql": "6ebf45a787a223241c8d9a47", "snowflake": "6ebf45a787a223241c8d9a47", @@ -22822,8 +22822,8 @@ "databricks": "cd9c38fc2cf84c8551e29278", "duckdb": "cd9c38fc2cf84c8551e29278", "generic": "cd9c38fc2cf84c8551e29278", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cd9c38fc2cf84c8551e29278", +"motherduck": "cd9c38fc2cf84c8551e29278", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cd9c38fc2cf84c8551e29278", "postgresql": "cd9c38fc2cf84c8551e29278", "snowflake": "cd9c38fc2cf84c8551e29278", @@ -22839,8 +22839,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -22850,18 +22850,18 @@ [ "type", { -"DuckDB": "944971a819b2498d3ecdc71d", -"None": "90882506184f4f707c46fdea", +"DuckDB": "225fc4f7b28377ba911e4a47", +"None": "a05c10798b5cb323b7dc3ed4", "bigquery": "f1cb74b07e7c8c7243c9034b", -"databricks": "37decbb811ce5abeffb05b4e", -"duckdb": "944971a819b2498d3ecdc71d", -"generic": "90882506184f4f707c46fdea", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "90882506184f4f707c46fdea", -"postgres": "61f2d73857de8729b66f99d2", -"postgresql": "61f2d73857de8729b66f99d2", +"databricks": "a05c10798b5cb323b7dc3ed4", +"duckdb": "225fc4f7b28377ba911e4a47", +"generic": "a05c10798b5cb323b7dc3ed4", +"motherduck": "225fc4f7b28377ba911e4a47", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "4e87e4788e5ac719db00d4e4", +"postgresql": "4e87e4788e5ac719db00d4e4", "snowflake": "225fc4f7b28377ba911e4a47", -"tsql": "5fb4ec49639b38cdf3ccfc38" +"tsql": "1a635a1b4dbecf67ace34158" } ], [ @@ -22869,14 +22869,14 @@ { "DuckDB": "dbf9ebbc7016f5ac5df2817e", "None": "dbf9ebbc7016f5ac5df2817e", -"bigquery": "dbf9ebbc7016f5ac5df2817e", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "dbf9ebbc7016f5ac5df2817e", "duckdb": "dbf9ebbc7016f5ac5df2817e", "generic": "dbf9ebbc7016f5ac5df2817e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "dbf9ebbc7016f5ac5df2817e", -"postgres": "dbf9ebbc7016f5ac5df2817e", -"postgresql": "dbf9ebbc7016f5ac5df2817e", +"motherduck": "dbf9ebbc7016f5ac5df2817e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "4cccf86e62d627a7a8b57726", +"postgresql": "4cccf86e62d627a7a8b57726", "snowflake": "dbf9ebbc7016f5ac5df2817e", "tsql": "dbf9ebbc7016f5ac5df2817e" } @@ -22890,8 +22890,8 @@ "databricks": "5debd5336e9bc9ec70e731b7", "duckdb": "5debd5336e9bc9ec70e731b7", "generic": "5debd5336e9bc9ec70e731b7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5debd5336e9bc9ec70e731b7", +"motherduck": "5debd5336e9bc9ec70e731b7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5debd5336e9bc9ec70e731b7", "postgresql": "5debd5336e9bc9ec70e731b7", "snowflake": "5debd5336e9bc9ec70e731b7", @@ -22903,14 +22903,14 @@ { "DuckDB": "d2c97d221599d038d9875873", "None": "d2c97d221599d038d9875873", -"bigquery": "d2c97d221599d038d9875873", +"bigquery": "55155766823b6a3a5e882fc2", "databricks": "d2c97d221599d038d9875873", "duckdb": "d2c97d221599d038d9875873", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "d2c97d221599d038d9875873", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -22924,8 +22924,8 @@ "databricks": "1fdc0b9f28b115c175e88d46", "duckdb": "1fdc0b9f28b115c175e88d46", "generic": "1fdc0b9f28b115c175e88d46", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1fdc0b9f28b115c175e88d46", +"motherduck": "1fdc0b9f28b115c175e88d46", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1fdc0b9f28b115c175e88d46", "postgresql": "1fdc0b9f28b115c175e88d46", "snowflake": "1fdc0b9f28b115c175e88d46", @@ -22941,8 +22941,8 @@ "databricks": "f38ef32a483f1c4f89ae309e", "duckdb": "f38ef32a483f1c4f89ae309e", "generic": "f38ef32a483f1c4f89ae309e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f38ef32a483f1c4f89ae309e", +"motherduck": "f38ef32a483f1c4f89ae309e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f38ef32a483f1c4f89ae309e", "postgresql": "f38ef32a483f1c4f89ae309e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -22958,8 +22958,8 @@ "databricks": "4281b54de06f589b3507035a", "duckdb": "5620e893a908c6743b863bf6", "generic": "5620e893a908c6743b863bf6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4281b54de06f589b3507035a", +"motherduck": "5620e893a908c6743b863bf6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5620e893a908c6743b863bf6", "postgresql": "5620e893a908c6743b863bf6", "snowflake": "5620e893a908c6743b863bf6", @@ -22975,8 +22975,8 @@ "databricks": "c0d59e65280108f563dbb04b", "duckdb": "c0d59e65280108f563dbb04b", "generic": "c0d59e65280108f563dbb04b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c0d59e65280108f563dbb04b", +"motherduck": "c0d59e65280108f563dbb04b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c0d59e65280108f563dbb04b", "postgresql": "c0d59e65280108f563dbb04b", "snowflake": "c0d59e65280108f563dbb04b", @@ -22992,10 +22992,10 @@ "databricks": "d16d75bc8832411932952499", "duckdb": "d16d75bc8832411932952499", "generic": "d16d75bc8832411932952499", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d16d75bc8832411932952499", -"postgres": "d16d75bc8832411932952499", -"postgresql": "d16d75bc8832411932952499", +"motherduck": "d16d75bc8832411932952499", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9372facf3130ca098b0fd00a", +"postgresql": "9372facf3130ca098b0fd00a", "snowflake": "d16d75bc8832411932952499", "tsql": "d16d75bc8832411932952499" } @@ -23004,17 +23004,17 @@ "type", { "DuckDB": "5abf4ec799a2ec32fb10da7e", -"None": "5abf4ec799a2ec32fb10da7e", +"None": "de89632e277dbc8c97115419", "bigquery": "5abf4ec799a2ec32fb10da7e", -"databricks": "5abf4ec799a2ec32fb10da7e", +"databricks": "de89632e277dbc8c97115419", "duckdb": "5abf4ec799a2ec32fb10da7e", -"generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", +"generic": "de89632e277dbc8c97115419", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5abf4ec799a2ec32fb10da7e", "postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "a5656d70e208254d1d3e9b4f", -"tsql": "5abf4ec799a2ec32fb10da7e" +"tsql": "de89632e277dbc8c97115419" } ], [ @@ -23026,8 +23026,8 @@ "databricks": "6cffd1617edd6454241ee732", "duckdb": "6cffd1617edd6454241ee732", "generic": "6cffd1617edd6454241ee732", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6cffd1617edd6454241ee732", +"motherduck": "6cffd1617edd6454241ee732", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6cffd1617edd6454241ee732", "postgresql": "6cffd1617edd6454241ee732", "snowflake": "6cffd1617edd6454241ee732", @@ -23043,10 +23043,10 @@ "databricks": "a686bb6db17ab079cfc79224", "duckdb": "a686bb6db17ab079cfc79224", "generic": "a686bb6db17ab079cfc79224", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a686bb6db17ab079cfc79224", -"postgres": "a686bb6db17ab079cfc79224", -"postgresql": "a686bb6db17ab079cfc79224", +"motherduck": "a686bb6db17ab079cfc79224", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "74a30f6aa9def0b58afc616c", +"postgresql": "74a30f6aa9def0b58afc616c", "snowflake": "1096c3c8687c8e8eb538ff74", "tsql": "a686bb6db17ab079cfc79224" } @@ -23060,8 +23060,8 @@ "databricks": "c752fd9fe2ad3b86b8b899da", "duckdb": "c752fd9fe2ad3b86b8b899da", "generic": "c752fd9fe2ad3b86b8b899da", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c752fd9fe2ad3b86b8b899da", +"motherduck": "c752fd9fe2ad3b86b8b899da", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e998cd8f0f74af0526b75ff0", "postgresql": "e998cd8f0f74af0526b75ff0", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -23077,8 +23077,8 @@ "databricks": "b52d5a83269c4ad64bd3416e", "duckdb": "b52d5a83269c4ad64bd3416e", "generic": "b52d5a83269c4ad64bd3416e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b52d5a83269c4ad64bd3416e", +"motherduck": "b52d5a83269c4ad64bd3416e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b52d5a83269c4ad64bd3416e", "postgresql": "b52d5a83269c4ad64bd3416e", "snowflake": "b52d5a83269c4ad64bd3416e", @@ -23088,16 +23088,16 @@ [ "type", { -"DuckDB": "aff2599f42411f45ff949ed9", -"None": "be47a14e7523acb3fcbd4b5b", +"DuckDB": "e3729d015bce3152bae7cd02", +"None": "f98c7776673323299fbfe6b7", "bigquery": "f98c7776673323299fbfe6b7", -"databricks": "2ed848a19b2b41fdf76d9a87", -"duckdb": "aff2599f42411f45ff949ed9", -"generic": "be47a14e7523acb3fcbd4b5b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "aff2599f42411f45ff949ed9", -"postgresql": "aff2599f42411f45ff949ed9", +"databricks": "f98c7776673323299fbfe6b7", +"duckdb": "e3729d015bce3152bae7cd02", +"generic": "f98c7776673323299fbfe6b7", +"motherduck": "e3729d015bce3152bae7cd02", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e3729d015bce3152bae7cd02", +"postgresql": "e3729d015bce3152bae7cd02", "snowflake": "a2a30dfc031641a60ba584fa", "tsql": "d1dc9a140dbe2eb1874c6ad7" } @@ -23106,17 +23106,17 @@ "type", { "DuckDB": "f2ed52f6bf46b4db9343551c", -"None": "f2ed52f6bf46b4db9343551c", -"bigquery": "f10bdd4d40eb495cbcecd31d", -"databricks": "f2ed52f6bf46b4db9343551c", +"None": "eeb8bd6105754e78339cd228", +"bigquery": "eeb8bd6105754e78339cd228", +"databricks": "eeb8bd6105754e78339cd228", "duckdb": "f2ed52f6bf46b4db9343551c", -"generic": "f2ed52f6bf46b4db9343551c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f2ed52f6bf46b4db9343551c", -"postgres": "f2ed52f6bf46b4db9343551c", -"postgresql": "f2ed52f6bf46b4db9343551c", +"generic": "eeb8bd6105754e78339cd228", +"motherduck": "f2ed52f6bf46b4db9343551c", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eeb8bd6105754e78339cd228", +"postgresql": "eeb8bd6105754e78339cd228", "snowflake": "f2ed52f6bf46b4db9343551c", -"tsql": "f2ed52f6bf46b4db9343551c" +"tsql": "eeb8bd6105754e78339cd228" } ], [ @@ -23124,14 +23124,14 @@ { "DuckDB": "de89632e277dbc8c97115419", "None": "de89632e277dbc8c97115419", -"bigquery": "de89632e277dbc8c97115419", +"bigquery": "5abf4ec799a2ec32fb10da7e", "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -23145,8 +23145,8 @@ "databricks": "88ee4a69672b4b9b3aa21e3d", "duckdb": "88ee4a69672b4b9b3aa21e3d", "generic": "88ee4a69672b4b9b3aa21e3d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "88ee4a69672b4b9b3aa21e3d", +"motherduck": "88ee4a69672b4b9b3aa21e3d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "88ee4a69672b4b9b3aa21e3d", "postgresql": "88ee4a69672b4b9b3aa21e3d", "snowflake": "88ee4a69672b4b9b3aa21e3d", @@ -23162,8 +23162,8 @@ "databricks": "ab5ad6180652b3b00d1f5b01", "duckdb": "ab5ad6180652b3b00d1f5b01", "generic": "ab5ad6180652b3b00d1f5b01", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ab5ad6180652b3b00d1f5b01", +"motherduck": "ab5ad6180652b3b00d1f5b01", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ab5ad6180652b3b00d1f5b01", "postgresql": "ab5ad6180652b3b00d1f5b01", "snowflake": "226beccc1d430773f4e67b70", @@ -23179,8 +23179,8 @@ "databricks": "555111267818cbd3d0b07105", "duckdb": "555111267818cbd3d0b07105", "generic": "555111267818cbd3d0b07105", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "555111267818cbd3d0b07105", +"motherduck": "555111267818cbd3d0b07105", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "555111267818cbd3d0b07105", "postgresql": "555111267818cbd3d0b07105", "snowflake": "555111267818cbd3d0b07105", @@ -23192,14 +23192,14 @@ { "DuckDB": "18db5afe2c1e80d1ee652b54", "None": "18db5afe2c1e80d1ee652b54", -"bigquery": "e1c36a5cdd2427ff2b089ac9", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "18db5afe2c1e80d1ee652b54", "duckdb": "18db5afe2c1e80d1ee652b54", "generic": "18db5afe2c1e80d1ee652b54", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "18db5afe2c1e80d1ee652b54", -"postgres": "18db5afe2c1e80d1ee652b54", -"postgresql": "18db5afe2c1e80d1ee652b54", +"motherduck": "18db5afe2c1e80d1ee652b54", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "47d64a5994d42a2b577166ea", +"postgresql": "47d64a5994d42a2b577166ea", "snowflake": "18db5afe2c1e80d1ee652b54", "tsql": "18db5afe2c1e80d1ee652b54" } @@ -23213,8 +23213,8 @@ "databricks": "9aff7fcc7d550e1a8d105471", "duckdb": "9aff7fcc7d550e1a8d105471", "generic": "9aff7fcc7d550e1a8d105471", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9aff7fcc7d550e1a8d105471", +"motherduck": "9aff7fcc7d550e1a8d105471", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9aff7fcc7d550e1a8d105471", "postgresql": "9aff7fcc7d550e1a8d105471", "snowflake": "9aff7fcc7d550e1a8d105471", @@ -23230,8 +23230,8 @@ "databricks": "e8b6e0bd2ded7b9eec6209e4", "duckdb": "e8b6e0bd2ded7b9eec6209e4", "generic": "e8b6e0bd2ded7b9eec6209e4", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e8b6e0bd2ded7b9eec6209e4", +"motherduck": "e8b6e0bd2ded7b9eec6209e4", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e8b6e0bd2ded7b9eec6209e4", "postgresql": "e8b6e0bd2ded7b9eec6209e4", "snowflake": "e8b6e0bd2ded7b9eec6209e4", @@ -23243,12 +23243,12 @@ { "DuckDB": "e08a957777bd278f921ca0ee", "None": "e08a957777bd278f921ca0ee", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "e08a957777bd278f921ca0ee", "duckdb": "e08a957777bd278f921ca0ee", "generic": "e08a957777bd278f921ca0ee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e08a957777bd278f921ca0ee", +"motherduck": "e08a957777bd278f921ca0ee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e08a957777bd278f921ca0ee", "postgresql": "e08a957777bd278f921ca0ee", "snowflake": "e08a957777bd278f921ca0ee", @@ -23264,8 +23264,8 @@ "databricks": "da72f481881cd577b304e9e7", "duckdb": "da72f481881cd577b304e9e7", "generic": "da72f481881cd577b304e9e7", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "da72f481881cd577b304e9e7", +"motherduck": "da72f481881cd577b304e9e7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "da72f481881cd577b304e9e7", "postgresql": "da72f481881cd577b304e9e7", "snowflake": "da72f481881cd577b304e9e7", @@ -23281,8 +23281,8 @@ "databricks": "b0791eeb8731828818f87f78", "duckdb": "b0791eeb8731828818f87f78", "generic": "b0791eeb8731828818f87f78", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b0791eeb8731828818f87f78", +"motherduck": "b0791eeb8731828818f87f78", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b0791eeb8731828818f87f78", "postgresql": "b0791eeb8731828818f87f78", "snowflake": "b0791eeb8731828818f87f78", @@ -23298,8 +23298,8 @@ "databricks": "d4b3585f1e47f5f60a2c28ee", "duckdb": "d4b3585f1e47f5f60a2c28ee", "generic": "d4b3585f1e47f5f60a2c28ee", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d4b3585f1e47f5f60a2c28ee", +"motherduck": "d4b3585f1e47f5f60a2c28ee", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d4b3585f1e47f5f60a2c28ee", "postgresql": "d4b3585f1e47f5f60a2c28ee", "snowflake": "d4b3585f1e47f5f60a2c28ee", @@ -23311,12 +23311,12 @@ { "DuckDB": "62368fc15cefd5807807b209", "None": "62368fc15cefd5807807b209", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "62368fc15cefd5807807b209", "duckdb": "62368fc15cefd5807807b209", "generic": "62368fc15cefd5807807b209", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "62368fc15cefd5807807b209", +"motherduck": "62368fc15cefd5807807b209", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "62368fc15cefd5807807b209", "postgresql": "62368fc15cefd5807807b209", "snowflake": "62368fc15cefd5807807b209", @@ -23328,14 +23328,14 @@ { "DuckDB": "4b356542044f1267fcfc487a", "None": "4b356542044f1267fcfc487a", -"bigquery": "4b356542044f1267fcfc487a", +"bigquery": "a5656d70e208254d1d3e9b4f", "databricks": "4b356542044f1267fcfc487a", "duckdb": "4b356542044f1267fcfc487a", "generic": "4b356542044f1267fcfc487a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4b356542044f1267fcfc487a", -"postgres": "4b356542044f1267fcfc487a", -"postgresql": "4b356542044f1267fcfc487a", +"motherduck": "4b356542044f1267fcfc487a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a5656d70e208254d1d3e9b4f", +"postgresql": "a5656d70e208254d1d3e9b4f", "snowflake": "4b356542044f1267fcfc487a", "tsql": "4b356542044f1267fcfc487a" } @@ -23349,8 +23349,8 @@ "databricks": "5abf4ec799a2ec32fb10da7e", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "5abf4ec799a2ec32fb10da7e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5abf4ec799a2ec32fb10da7e", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5abf4ec799a2ec32fb10da7e", "postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -23366,8 +23366,8 @@ "databricks": "7ca149227eff68da5bfa0404", "duckdb": "7ca149227eff68da5bfa0404", "generic": "7ca149227eff68da5bfa0404", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7ca149227eff68da5bfa0404", +"motherduck": "7ca149227eff68da5bfa0404", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7ca149227eff68da5bfa0404", "postgresql": "7ca149227eff68da5bfa0404", "snowflake": "7ca149227eff68da5bfa0404", @@ -23383,8 +23383,8 @@ "databricks": "3dbbe73ee4310c73030e8110", "duckdb": "3dbbe73ee4310c73030e8110", "generic": "3dbbe73ee4310c73030e8110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3dbbe73ee4310c73030e8110", +"motherduck": "3dbbe73ee4310c73030e8110", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3dbbe73ee4310c73030e8110", "postgresql": "3dbbe73ee4310c73030e8110", "snowflake": "f43dac38f34a1c0618a3f812", @@ -23400,8 +23400,8 @@ "databricks": "19cc45192479751e55bffbfe", "duckdb": "19cc45192479751e55bffbfe", "generic": "19cc45192479751e55bffbfe", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19cc45192479751e55bffbfe", +"motherduck": "19cc45192479751e55bffbfe", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "19cc45192479751e55bffbfe", "postgresql": "19cc45192479751e55bffbfe", "snowflake": "19cc45192479751e55bffbfe", @@ -23417,8 +23417,8 @@ "databricks": "300e2b67af892b463d85f9cd", "duckdb": "300e2b67af892b463d85f9cd", "generic": "300e2b67af892b463d85f9cd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "300e2b67af892b463d85f9cd", +"motherduck": "300e2b67af892b463d85f9cd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "300e2b67af892b463d85f9cd", "postgresql": "300e2b67af892b463d85f9cd", "snowflake": "300e2b67af892b463d85f9cd", @@ -23434,8 +23434,8 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "1e75e5227bea0ae294ac7af1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19bdd92ea0cc5fb028657510", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "19bdd92ea0cc5fb028657510", "postgresql": "19bdd92ea0cc5fb028657510", "snowflake": "8ff614b7306c0edbe36ce00b", @@ -23451,8 +23451,8 @@ "databricks": "94f6df33eccb97170eccb01b", "duckdb": "94f6df33eccb97170eccb01b", "generic": "94f6df33eccb97170eccb01b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "94f6df33eccb97170eccb01b", +"motherduck": "94f6df33eccb97170eccb01b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "94f6df33eccb97170eccb01b", "postgresql": "94f6df33eccb97170eccb01b", "snowflake": "94f6df33eccb97170eccb01b", @@ -23468,10 +23468,10 @@ "databricks": "19a1a80ffc06169f32694de8", "duckdb": "19a1a80ffc06169f32694de8", "generic": "19a1a80ffc06169f32694de8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "19a1a80ffc06169f32694de8", -"postgres": "19a1a80ffc06169f32694de8", -"postgresql": "19a1a80ffc06169f32694de8", +"motherduck": "19a1a80ffc06169f32694de8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "ab1f5f46e69284778bd66d58", +"postgresql": "ab1f5f46e69284778bd66d58", "snowflake": "19a1a80ffc06169f32694de8", "tsql": "19a1a80ffc06169f32694de8" } @@ -23485,8 +23485,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -23498,14 +23498,14 @@ { "DuckDB": "de89632e277dbc8c97115419", "None": "de89632e277dbc8c97115419", -"bigquery": "de89632e277dbc8c97115419", +"bigquery": "5abf4ec799a2ec32fb10da7e", "databricks": "de89632e277dbc8c97115419", "duckdb": "de89632e277dbc8c97115419", "generic": "de89632e277dbc8c97115419", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "de89632e277dbc8c97115419", -"postgres": "de89632e277dbc8c97115419", -"postgresql": "de89632e277dbc8c97115419", +"motherduck": "de89632e277dbc8c97115419", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5abf4ec799a2ec32fb10da7e", +"postgresql": "5abf4ec799a2ec32fb10da7e", "snowflake": "4b356542044f1267fcfc487a", "tsql": "de89632e277dbc8c97115419" } @@ -23519,8 +23519,8 @@ "databricks": "2444c03418f9f1b2f23f2ec8", "duckdb": "2444c03418f9f1b2f23f2ec8", "generic": "2444c03418f9f1b2f23f2ec8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2444c03418f9f1b2f23f2ec8", +"motherduck": "2444c03418f9f1b2f23f2ec8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2444c03418f9f1b2f23f2ec8", "postgresql": "2444c03418f9f1b2f23f2ec8", "snowflake": "2444c03418f9f1b2f23f2ec8", @@ -23536,10 +23536,10 @@ "databricks": "d2c97d221599d038d9875873", "duckdb": "f7fca17b74cc50ae3de8c826", "generic": "d2c97d221599d038d9875873", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d2c97d221599d038d9875873", -"postgres": "d2c97d221599d038d9875873", -"postgresql": "d2c97d221599d038d9875873", +"motherduck": "f7fca17b74cc50ae3de8c826", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55155766823b6a3a5e882fc2", +"postgresql": "55155766823b6a3a5e882fc2", "snowflake": "d2c97d221599d038d9875873", "tsql": "d2c97d221599d038d9875873" } @@ -23549,14 +23549,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -23566,14 +23566,14 @@ { "DuckDB": "b561884132dbe7e42b719110", "None": "b561884132dbe7e42b719110", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "b561884132dbe7e42b719110", "duckdb": "b561884132dbe7e42b719110", "generic": "b561884132dbe7e42b719110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b561884132dbe7e42b719110", -"postgres": "b561884132dbe7e42b719110", -"postgresql": "b561884132dbe7e42b719110", +"motherduck": "b561884132dbe7e42b719110", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5aa51d84ac5e6c7a9306f348", +"postgresql": "5aa51d84ac5e6c7a9306f348", "snowflake": "b561884132dbe7e42b719110", "tsql": "b561884132dbe7e42b719110" } @@ -23587,10 +23587,10 @@ "databricks": "f8219c960720043f0662a603", "duckdb": "35a9c5c1419bff507cf65ae2", "generic": "f8219c960720043f0662a603", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f8219c960720043f0662a603", -"postgres": "f8219c960720043f0662a603", -"postgresql": "f8219c960720043f0662a603", +"motherduck": "35a9c5c1419bff507cf65ae2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "35a9c5c1419bff507cf65ae2", +"postgresql": "35a9c5c1419bff507cf65ae2", "snowflake": "f8219c960720043f0662a603", "tsql": "f8219c960720043f0662a603" } @@ -23604,10 +23604,10 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "396b2ce32efb5365b393c230", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", -"postgres": "e57ac1541fb51b362cd5b470", -"postgresql": "e57ac1541fb51b362cd5b470", +"motherduck": "396b2ce32efb5365b393c230", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "396b2ce32efb5365b393c230", +"postgresql": "396b2ce32efb5365b393c230", "snowflake": "4b356542044f1267fcfc487a", "tsql": "e57ac1541fb51b362cd5b470" } @@ -23621,8 +23621,8 @@ "databricks": "f16105cbc61d547e6c08efc8", "duckdb": "f16105cbc61d547e6c08efc8", "generic": "f16105cbc61d547e6c08efc8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f16105cbc61d547e6c08efc8", +"motherduck": "f16105cbc61d547e6c08efc8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f16105cbc61d547e6c08efc8", "postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -23638,8 +23638,8 @@ "databricks": "f6140be64a327a15b42b923d", "duckdb": "f6140be64a327a15b42b923d", "generic": "f6140be64a327a15b42b923d", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f6140be64a327a15b42b923d", +"motherduck": "f6140be64a327a15b42b923d", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f6140be64a327a15b42b923d", "postgresql": "f6140be64a327a15b42b923d", "snowflake": "f6140be64a327a15b42b923d", @@ -23655,8 +23655,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -23672,8 +23672,8 @@ "databricks": "25cdfa949946952336077d37", "duckdb": "25cdfa949946952336077d37", "generic": "25cdfa949946952336077d37", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "25cdfa949946952336077d37", +"motherduck": "25cdfa949946952336077d37", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "25cdfa949946952336077d37", "postgresql": "25cdfa949946952336077d37", "snowflake": "25cdfa949946952336077d37", @@ -23689,8 +23689,8 @@ "databricks": "6d7ab232e65fe8d85c7169ae", "duckdb": "6d7ab232e65fe8d85c7169ae", "generic": "6d7ab232e65fe8d85c7169ae", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6d7ab232e65fe8d85c7169ae", +"motherduck": "6d7ab232e65fe8d85c7169ae", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a6659d96bbfa5da75e69e22d", "postgresql": "a6659d96bbfa5da75e69e22d", "snowflake": "6d7ab232e65fe8d85c7169ae", @@ -23706,8 +23706,8 @@ "databricks": "1509a96170cb94e0a99bbf00", "duckdb": "13bc61bc9a039c8b798c5322", "generic": "1509a96170cb94e0a99bbf00", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "13bc61bc9a039c8b798c5322", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "13bc61bc9a039c8b798c5322", "postgresql": "13bc61bc9a039c8b798c5322", "snowflake": "d5cc04b4579263e52cd194bb", @@ -23723,8 +23723,8 @@ "databricks": "d6de1c22b8b95cc863db57ba", "duckdb": "d6de1c22b8b95cc863db57ba", "generic": "d6de1c22b8b95cc863db57ba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d6de1c22b8b95cc863db57ba", +"motherduck": "d6de1c22b8b95cc863db57ba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d6de1c22b8b95cc863db57ba", "postgresql": "d6de1c22b8b95cc863db57ba", "snowflake": "d6de1c22b8b95cc863db57ba", @@ -23740,10 +23740,10 @@ "databricks": "2c6b371b030464f525066893", "duckdb": "2c6b371b030464f525066893", "generic": "2c6b371b030464f525066893", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2c6b371b030464f525066893", -"postgres": "2c6b371b030464f525066893", -"postgresql": "2c6b371b030464f525066893", +"motherduck": "2c6b371b030464f525066893", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3feb479faeec777c2ade8afd", +"postgresql": "3feb479faeec777c2ade8afd", "snowflake": "2c6b371b030464f525066893", "tsql": "2c6b371b030464f525066893" } @@ -23757,8 +23757,8 @@ "databricks": "46ec3e19e05a6cb29854ccac", "duckdb": "35e216b6921bf843994f2eea", "generic": "46ec3e19e05a6cb29854ccac", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "46ec3e19e05a6cb29854ccac", +"motherduck": "35e216b6921bf843994f2eea", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "46ec3e19e05a6cb29854ccac", "postgresql": "46ec3e19e05a6cb29854ccac", "snowflake": "46ec3e19e05a6cb29854ccac", @@ -23770,14 +23770,14 @@ { "DuckDB": "08736485547ba339930697e9", "None": "08736485547ba339930697e9", -"bigquery": "08736485547ba339930697e9", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "08736485547ba339930697e9", "duckdb": "08736485547ba339930697e9", "generic": "08736485547ba339930697e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "08736485547ba339930697e9", -"postgres": "08736485547ba339930697e9", -"postgresql": "08736485547ba339930697e9", +"motherduck": "08736485547ba339930697e9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eecd452b4f5f3f4133d0bd0a", +"postgresql": "eecd452b4f5f3f4133d0bd0a", "snowflake": "08736485547ba339930697e9", "tsql": "08736485547ba339930697e9" } @@ -23787,14 +23787,14 @@ { "DuckDB": "2fcd11f2fdbe6c4498c4833e", "None": "2fcd11f2fdbe6c4498c4833e", -"bigquery": "2fcd11f2fdbe6c4498c4833e", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "2fcd11f2fdbe6c4498c4833e", "duckdb": "2fcd11f2fdbe6c4498c4833e", "generic": "2fcd11f2fdbe6c4498c4833e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2fcd11f2fdbe6c4498c4833e", -"postgres": "2fcd11f2fdbe6c4498c4833e", -"postgresql": "2fcd11f2fdbe6c4498c4833e", +"motherduck": "2fcd11f2fdbe6c4498c4833e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3255b7052c624f34aab6633f", +"postgresql": "3255b7052c624f34aab6633f", "snowflake": "2fcd11f2fdbe6c4498c4833e", "tsql": "2fcd11f2fdbe6c4498c4833e" } @@ -23804,14 +23804,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -23825,8 +23825,8 @@ "databricks": "c844c96e1e3ffc72d5f90df9", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "c844c96e1e3ffc72d5f90df9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "28eb0d6de9724959ce5ba43e", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c844c96e1e3ffc72d5f90df9", "postgresql": "c844c96e1e3ffc72d5f90df9", "snowflake": "c844c96e1e3ffc72d5f90df9", @@ -23838,12 +23838,12 @@ { "DuckDB": "5c28019dce48a74708c90a76", "None": "5c28019dce48a74708c90a76", -"bigquery": "f28a96f0eb38ad8874f6ec5d", +"bigquery": "5c28019dce48a74708c90a76", "databricks": "5c28019dce48a74708c90a76", "duckdb": "5c28019dce48a74708c90a76", "generic": "5c28019dce48a74708c90a76", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "5c28019dce48a74708c90a76", +"motherduck": "5c28019dce48a74708c90a76", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "5c28019dce48a74708c90a76", "postgresql": "5c28019dce48a74708c90a76", "snowflake": "a5656d70e208254d1d3e9b4f", @@ -23855,14 +23855,14 @@ { "DuckDB": "2fcd11f2fdbe6c4498c4833e", "None": "2fcd11f2fdbe6c4498c4833e", -"bigquery": "2fcd11f2fdbe6c4498c4833e", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "2fcd11f2fdbe6c4498c4833e", "duckdb": "2fcd11f2fdbe6c4498c4833e", "generic": "2fcd11f2fdbe6c4498c4833e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2fcd11f2fdbe6c4498c4833e", -"postgres": "2fcd11f2fdbe6c4498c4833e", -"postgresql": "2fcd11f2fdbe6c4498c4833e", +"motherduck": "2fcd11f2fdbe6c4498c4833e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3255b7052c624f34aab6633f", +"postgresql": "3255b7052c624f34aab6633f", "snowflake": "2fcd11f2fdbe6c4498c4833e", "tsql": "2fcd11f2fdbe6c4498c4833e" } @@ -23876,8 +23876,8 @@ "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "aab0389e2b5470136660bf8a", "postgresql": "aab0389e2b5470136660bf8a", "snowflake": "97a20344d811fb77c7690863", @@ -23888,17 +23888,17 @@ "type", { "DuckDB": "6f4372a332076048e56d5076", -"None": "6f4372a332076048e56d5076", -"bigquery": "74a30f6aa9def0b58afc616c", -"databricks": "6f4372a332076048e56d5076", +"None": "fa78cfa46a78783d069e2fc5", +"bigquery": "b0477b36767a62145aa9158c", +"databricks": "fa78cfa46a78783d069e2fc5", "duckdb": "6f4372a332076048e56d5076", -"generic": "6f4372a332076048e56d5076", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6f4372a332076048e56d5076", +"generic": "fa78cfa46a78783d069e2fc5", +"motherduck": "6f4372a332076048e56d5076", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "6f4372a332076048e56d5076", "postgresql": "6f4372a332076048e56d5076", "snowflake": "daeeb0f00b3ee4211b8da00f", -"tsql": "6f4372a332076048e56d5076" +"tsql": "fa78cfa46a78783d069e2fc5" } ], [ @@ -23910,8 +23910,8 @@ "databricks": "7a00586f9fdb1d97256bfff8", "duckdb": "7a00586f9fdb1d97256bfff8", "generic": "7a00586f9fdb1d97256bfff8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7a00586f9fdb1d97256bfff8", +"motherduck": "7a00586f9fdb1d97256bfff8", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7a00586f9fdb1d97256bfff8", "postgresql": "7a00586f9fdb1d97256bfff8", "snowflake": "7a00586f9fdb1d97256bfff8", @@ -23927,8 +23927,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -23944,8 +23944,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -23961,8 +23961,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -23974,14 +23974,14 @@ { "DuckDB": "aab0389e2b5470136660bf8a", "None": "aab0389e2b5470136660bf8a", -"bigquery": "c9b810639795a7bfab91b98d", +"bigquery": "a428302e4848ffe877284c84", "databricks": "aab0389e2b5470136660bf8a", "duckdb": "aab0389e2b5470136660bf8a", "generic": "aab0389e2b5470136660bf8a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "aab0389e2b5470136660bf8a", -"postgres": "aab0389e2b5470136660bf8a", -"postgresql": "aab0389e2b5470136660bf8a", +"motherduck": "aab0389e2b5470136660bf8a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f16105cbc61d547e6c08efc8", +"postgresql": "f16105cbc61d547e6c08efc8", "snowflake": "97a20344d811fb77c7690863", "tsql": "aab0389e2b5470136660bf8a" } @@ -23991,12 +23991,12 @@ { "DuckDB": "62368fc15cefd5807807b209", "None": "62368fc15cefd5807807b209", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "62368fc15cefd5807807b209", "duckdb": "62368fc15cefd5807807b209", "generic": "62368fc15cefd5807807b209", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "62368fc15cefd5807807b209", +"motherduck": "62368fc15cefd5807807b209", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "62368fc15cefd5807807b209", "postgresql": "62368fc15cefd5807807b209", "snowflake": "62368fc15cefd5807807b209", @@ -24012,8 +24012,8 @@ "databricks": "38b2ec94bf02be40007ce525", "duckdb": "38b2ec94bf02be40007ce525", "generic": "38b2ec94bf02be40007ce525", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "38b2ec94bf02be40007ce525", +"motherduck": "38b2ec94bf02be40007ce525", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "38b2ec94bf02be40007ce525", "postgresql": "38b2ec94bf02be40007ce525", "snowflake": "38b2ec94bf02be40007ce525", @@ -24023,17 +24023,17 @@ [ "type", { -"DuckDB": "89cc3662f602a13aef39eb80", -"None": "f2bbf59a9c02f59ca89e66b6", -"bigquery": "f2bbf59a9c02f59ca89e66b6", -"databricks": "f2bbf59a9c02f59ca89e66b6", -"duckdb": "89cc3662f602a13aef39eb80", -"generic": "f2bbf59a9c02f59ca89e66b6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "89cc3662f602a13aef39eb80", -"postgresql": "89cc3662f602a13aef39eb80", -"snowflake": "6f88ef12d95c26bf8f0bd9e5", +"DuckDB": "01e3dfc024c37a8d62c7f810", +"None": "3a4d8bca5124769db23a43df", +"bigquery": "3a4d8bca5124769db23a43df", +"databricks": "3a4d8bca5124769db23a43df", +"duckdb": "01e3dfc024c37a8d62c7f810", +"generic": "3a4d8bca5124769db23a43df", +"motherduck": "01e3dfc024c37a8d62c7f810", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "01e3dfc024c37a8d62c7f810", +"postgresql": "01e3dfc024c37a8d62c7f810", +"snowflake": "db03b5ccf153c75e43846a6a", "tsql": "d1dc9a140dbe2eb1874c6ad7" } ], @@ -24046,8 +24046,8 @@ "databricks": "0703bf71a54942bdaa28406e", "duckdb": "0703bf71a54942bdaa28406e", "generic": "0703bf71a54942bdaa28406e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0703bf71a54942bdaa28406e", +"motherduck": "0703bf71a54942bdaa28406e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0703bf71a54942bdaa28406e", "postgresql": "0703bf71a54942bdaa28406e", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -24060,11 +24060,11 @@ "DuckDB": "ef2689646fd9e772e27d2727", "None": "ef2689646fd9e772e27d2727", "bigquery": "ef2689646fd9e772e27d2727", -"databricks": "e63b3aab09c82955e2560928", +"databricks": "ef2689646fd9e772e27d2727", "duckdb": "ef2689646fd9e772e27d2727", "generic": "ef2689646fd9e772e27d2727", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "ef2689646fd9e772e27d2727", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ef2689646fd9e772e27d2727", "postgresql": "ef2689646fd9e772e27d2727", "snowflake": "ef2689646fd9e772e27d2727", @@ -24075,17 +24075,17 @@ "type", { "DuckDB": "c43574432afc90bcba6944b2", -"None": "7040afbb3a088baf55e328b2", -"bigquery": "7040afbb3a088baf55e328b2", -"databricks": "ba611057434e43344935471b", +"None": "61c3e35de716257a33271a64", +"bigquery": "61c3e35de716257a33271a64", +"databricks": "61c3e35de716257a33271a64", "duckdb": "c43574432afc90bcba6944b2", -"generic": "7040afbb3a088baf55e328b2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "1b3243409566f14d81c11fff", -"postgresql": "1b3243409566f14d81c11fff", +"generic": "61c3e35de716257a33271a64", +"motherduck": "c43574432afc90bcba6944b2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "61c3e35de716257a33271a64", +"postgresql": "61c3e35de716257a33271a64", "snowflake": "5b6535982c7d4576e34ee7cb", -"tsql": "d1dc9a140dbe2eb1874c6ad7" +"tsql": "61c3e35de716257a33271a64" } ], [ @@ -24097,8 +24097,8 @@ "databricks": "3dbbe73ee4310c73030e8110", "duckdb": "3dbbe73ee4310c73030e8110", "generic": "3dbbe73ee4310c73030e8110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3dbbe73ee4310c73030e8110", +"motherduck": "3dbbe73ee4310c73030e8110", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3dbbe73ee4310c73030e8110", "postgresql": "3dbbe73ee4310c73030e8110", "snowflake": "f43dac38f34a1c0618a3f812", @@ -24114,8 +24114,8 @@ "databricks": "b46dfa976d5ba04f95bea32b", "duckdb": "b46dfa976d5ba04f95bea32b", "generic": "b46dfa976d5ba04f95bea32b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b46dfa976d5ba04f95bea32b", +"motherduck": "b46dfa976d5ba04f95bea32b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "34dcdfe3e3afe6140e1353e0", "postgresql": "34dcdfe3e3afe6140e1353e0", "snowflake": "b46dfa976d5ba04f95bea32b", @@ -24131,8 +24131,8 @@ "databricks": "031c4b14dc8b97fdb38e28b3", "duckdb": "bc9875824f2c0eb90fcb5e51", "generic": "0289c868616e51dc348bba36", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe2c1943dc029130eda3f066", +"motherduck": "bc9875824f2c0eb90fcb5e51", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fe2c1943dc029130eda3f066", "postgresql": "fe2c1943dc029130eda3f066", "snowflake": "ffc35af553194c8ccffc9058", @@ -24148,8 +24148,8 @@ "databricks": "c844c96e1e3ffc72d5f90df9", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "c844c96e1e3ffc72d5f90df9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "28eb0d6de9724959ce5ba43e", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c844c96e1e3ffc72d5f90df9", "postgresql": "c844c96e1e3ffc72d5f90df9", "snowflake": "c844c96e1e3ffc72d5f90df9", @@ -24165,8 +24165,8 @@ "databricks": "3dbbe73ee4310c73030e8110", "duckdb": "3dbbe73ee4310c73030e8110", "generic": "3dbbe73ee4310c73030e8110", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3dbbe73ee4310c73030e8110", +"motherduck": "3dbbe73ee4310c73030e8110", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3dbbe73ee4310c73030e8110", "postgresql": "3dbbe73ee4310c73030e8110", "snowflake": "f43dac38f34a1c0618a3f812", @@ -24182,8 +24182,8 @@ "databricks": "04d8552335eed867485d59b8", "duckdb": "8f29d402cac8d3b922d1a4e7", "generic": "04d8552335eed867485d59b8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "8f29d402cac8d3b922d1a4e7", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "8f29d402cac8d3b922d1a4e7", "postgresql": "8f29d402cac8d3b922d1a4e7", "snowflake": "c60d34b521887e82716fd787", @@ -24199,8 +24199,8 @@ "databricks": "d53793d8f8d21c36a117dedb", "duckdb": "d53793d8f8d21c36a117dedb", "generic": "d53793d8f8d21c36a117dedb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d53793d8f8d21c36a117dedb", +"motherduck": "d53793d8f8d21c36a117dedb", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d53793d8f8d21c36a117dedb", "postgresql": "d53793d8f8d21c36a117dedb", "snowflake": "d53793d8f8d21c36a117dedb", @@ -24216,8 +24216,8 @@ "databricks": "251aba3fef503ce64556c701", "duckdb": "251aba3fef503ce64556c701", "generic": "251aba3fef503ce64556c701", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "251aba3fef503ce64556c701", +"motherduck": "251aba3fef503ce64556c701", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b7d6fc051a3c1ea6deb29ff4", "postgresql": "b7d6fc051a3c1ea6deb29ff4", "snowflake": "251aba3fef503ce64556c701", @@ -24229,14 +24229,14 @@ { "DuckDB": "df19c722959a4259621a1e09", "None": "df19c722959a4259621a1e09", -"bigquery": "df19c722959a4259621a1e09", +"bigquery": "c7c38fdeaeb7858a44976f1d", "databricks": "df19c722959a4259621a1e09", "duckdb": "df19c722959a4259621a1e09", "generic": "df19c722959a4259621a1e09", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "df19c722959a4259621a1e09", -"postgres": "df19c722959a4259621a1e09", -"postgresql": "df19c722959a4259621a1e09", +"motherduck": "df19c722959a4259621a1e09", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "1d7dd2736322bc33dae77252", +"postgresql": "1d7dd2736322bc33dae77252", "snowflake": "df19c722959a4259621a1e09", "tsql": "df19c722959a4259621a1e09" } @@ -24250,8 +24250,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -24267,8 +24267,8 @@ "databricks": "4662a1758442ce44b830269f", "duckdb": "4662a1758442ce44b830269f", "generic": "4662a1758442ce44b830269f", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4662a1758442ce44b830269f", +"motherduck": "4662a1758442ce44b830269f", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "4662a1758442ce44b830269f", "postgresql": "4662a1758442ce44b830269f", "snowflake": "4662a1758442ce44b830269f", @@ -24284,8 +24284,8 @@ "databricks": "73975a560983dfcdc361f145", "duckdb": "73975a560983dfcdc361f145", "generic": "73975a560983dfcdc361f145", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "73975a560983dfcdc361f145", +"motherduck": "73975a560983dfcdc361f145", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "73975a560983dfcdc361f145", "postgresql": "73975a560983dfcdc361f145", "snowflake": "73975a560983dfcdc361f145", @@ -24301,8 +24301,8 @@ "databricks": "c844c96e1e3ffc72d5f90df9", "duckdb": "8a3f094f18fb4047f0febf59", "generic": "c844c96e1e3ffc72d5f90df9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "28eb0d6de9724959ce5ba43e", +"motherduck": "8a3f094f18fb4047f0febf59", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c844c96e1e3ffc72d5f90df9", "postgresql": "c844c96e1e3ffc72d5f90df9", "snowflake": "c844c96e1e3ffc72d5f90df9", @@ -24318,8 +24318,8 @@ "databricks": "fedd65248cdf63b24b8c1567", "duckdb": "fedd65248cdf63b24b8c1567", "generic": "fedd65248cdf63b24b8c1567", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fedd65248cdf63b24b8c1567", +"motherduck": "fedd65248cdf63b24b8c1567", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fedd65248cdf63b24b8c1567", "postgresql": "fedd65248cdf63b24b8c1567", "snowflake": "fedd65248cdf63b24b8c1567", @@ -24330,17 +24330,17 @@ "type", { "DuckDB": "c50a316d091c821866e4bfba", -"None": "c50a316d091c821866e4bfba", -"bigquery": "c50a316d091c821866e4bfba", -"databricks": "c50a316d091c821866e4bfba", +"None": "e6ffdece2977be55da73b59a", +"bigquery": "e6ffdece2977be55da73b59a", +"databricks": "e6ffdece2977be55da73b59a", "duckdb": "c50a316d091c821866e4bfba", -"generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"generic": "e6ffdece2977be55da73b59a", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", -"tsql": "c50a316d091c821866e4bfba" +"tsql": "e6ffdece2977be55da73b59a" } ], [ @@ -24352,8 +24352,8 @@ "databricks": "d79c3ac70093cb4cb531e71c", "duckdb": "d79c3ac70093cb4cb531e71c", "generic": "d79c3ac70093cb4cb531e71c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d79c3ac70093cb4cb531e71c", +"motherduck": "d79c3ac70093cb4cb531e71c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d79c3ac70093cb4cb531e71c", "postgresql": "d79c3ac70093cb4cb531e71c", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -24369,10 +24369,10 @@ "databricks": "3673b4fbbd8a7fed7120ec2b", "duckdb": "3673b4fbbd8a7fed7120ec2b", "generic": "3673b4fbbd8a7fed7120ec2b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3673b4fbbd8a7fed7120ec2b", -"postgres": "3673b4fbbd8a7fed7120ec2b", -"postgresql": "3673b4fbbd8a7fed7120ec2b", +"motherduck": "3673b4fbbd8a7fed7120ec2b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9aff7fcc7d550e1a8d105471", +"postgresql": "9aff7fcc7d550e1a8d105471", "snowflake": "3673b4fbbd8a7fed7120ec2b", "tsql": "3673b4fbbd8a7fed7120ec2b" } @@ -24381,15 +24381,15 @@ "type", { "DuckDB": "d2e8f9f7288b371199b1652e", -"None": "9bca83e64bfacf0a80ca9b34", +"None": "fe1b4290ba0c2395d949643d", "bigquery": "fe1b4290ba0c2395d949643d", "databricks": "fe1b4290ba0c2395d949643d", "duckdb": "d2e8f9f7288b371199b1652e", -"generic": "9bca83e64bfacf0a80ca9b34", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe1b4290ba0c2395d949643d", -"postgres": "d2e8f9f7288b371199b1652e", -"postgresql": "d2e8f9f7288b371199b1652e", +"generic": "fe1b4290ba0c2395d949643d", +"motherduck": "d2e8f9f7288b371199b1652e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "e0367d4e3fcf904cd5657220", +"postgresql": "e0367d4e3fcf904cd5657220", "snowflake": "c326a07d4a8adffde91e55cd", "tsql": "fe1b4290ba0c2395d949643d" } @@ -24403,8 +24403,8 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "b8321619b794db091c9e96a1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b8321619b794db091c9e96a1", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b8321619b794db091c9e96a1", "postgresql": "b8321619b794db091c9e96a1", "snowflake": "b8321619b794db091c9e96a1", @@ -24420,8 +24420,8 @@ "databricks": "77ffdb80029bd6e2cca768ad", "duckdb": "77ffdb80029bd6e2cca768ad", "generic": "77ffdb80029bd6e2cca768ad", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "77ffdb80029bd6e2cca768ad", +"motherduck": "77ffdb80029bd6e2cca768ad", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "77ffdb80029bd6e2cca768ad", "postgresql": "77ffdb80029bd6e2cca768ad", "snowflake": "77ffdb80029bd6e2cca768ad", @@ -24433,14 +24433,14 @@ { "DuckDB": "b69a57be16780e0a5e4acadb", "None": "b69a57be16780e0a5e4acadb", -"bigquery": "b69a57be16780e0a5e4acadb", +"bigquery": "67d251c042daee0bb2bf7351", "databricks": "b69a57be16780e0a5e4acadb", "duckdb": "b69a57be16780e0a5e4acadb", "generic": "b69a57be16780e0a5e4acadb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b69a57be16780e0a5e4acadb", -"postgres": "b69a57be16780e0a5e4acadb", -"postgresql": "b69a57be16780e0a5e4acadb", +"motherduck": "b69a57be16780e0a5e4acadb", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a7d1c1767c3d4e900c7d3cb4", +"postgresql": "a7d1c1767c3d4e900c7d3cb4", "snowflake": "b69a57be16780e0a5e4acadb", "tsql": "b69a57be16780e0a5e4acadb" } @@ -24454,8 +24454,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -24471,8 +24471,8 @@ "databricks": "f1625f38cf20f9627bc717a9", "duckdb": "f1625f38cf20f9627bc717a9", "generic": "f1625f38cf20f9627bc717a9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "f1625f38cf20f9627bc717a9", +"motherduck": "f1625f38cf20f9627bc717a9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "f1625f38cf20f9627bc717a9", "postgresql": "f1625f38cf20f9627bc717a9", "snowflake": "f1625f38cf20f9627bc717a9", @@ -24488,8 +24488,8 @@ "databricks": "e998cd8f0f74af0526b75ff0", "duckdb": "e998cd8f0f74af0526b75ff0", "generic": "e998cd8f0f74af0526b75ff0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e998cd8f0f74af0526b75ff0", +"motherduck": "e998cd8f0f74af0526b75ff0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e998cd8f0f74af0526b75ff0", "postgresql": "e998cd8f0f74af0526b75ff0", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -24500,17 +24500,17 @@ "type", { "DuckDB": "fa45b7e4a9ef3b5a9c5781af", -"None": "fa45b7e4a9ef3b5a9c5781af", -"bigquery": "fa45b7e4a9ef3b5a9c5781af", -"databricks": "fa45b7e4a9ef3b5a9c5781af", +"None": "ebe2513b6cb4001e42cc464b", +"bigquery": "0c43dc837a50933667588ef1", +"databricks": "ebe2513b6cb4001e42cc464b", "duckdb": "fa45b7e4a9ef3b5a9c5781af", -"generic": "fa45b7e4a9ef3b5a9c5781af", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fa45b7e4a9ef3b5a9c5781af", +"generic": "ebe2513b6cb4001e42cc464b", +"motherduck": "fa45b7e4a9ef3b5a9c5781af", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fa45b7e4a9ef3b5a9c5781af", "postgresql": "fa45b7e4a9ef3b5a9c5781af", "snowflake": "fa45b7e4a9ef3b5a9c5781af", -"tsql": "fa45b7e4a9ef3b5a9c5781af" +"tsql": "ebe2513b6cb4001e42cc464b" } ], [ @@ -24522,10 +24522,10 @@ "databricks": "4b356542044f1267fcfc487a", "duckdb": "5abf4ec799a2ec32fb10da7e", "generic": "4b356542044f1267fcfc487a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "4b356542044f1267fcfc487a", -"postgres": "4b356542044f1267fcfc487a", -"postgresql": "4b356542044f1267fcfc487a", +"motherduck": "5abf4ec799a2ec32fb10da7e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "a5656d70e208254d1d3e9b4f", +"postgresql": "a5656d70e208254d1d3e9b4f", "snowflake": "4b356542044f1267fcfc487a", "tsql": "4b356542044f1267fcfc487a" } @@ -24534,34 +24534,34 @@ "type", { "DuckDB": "1ebac487198b6c90b027faab", -"None": "1ebac487198b6c90b027faab", -"bigquery": "a428302e4848ffe877284c84", -"databricks": "1ebac487198b6c90b027faab", +"None": "79278352c17c9de0f5a28af5", +"bigquery": "c9b810639795a7bfab91b98d", +"databricks": "79278352c17c9de0f5a28af5", "duckdb": "1ebac487198b6c90b027faab", -"generic": "1ebac487198b6c90b027faab", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1ebac487198b6c90b027faab", -"postgres": "1ebac487198b6c90b027faab", -"postgresql": "1ebac487198b6c90b027faab", -"snowflake": "652ff8b21f638eac8fdc46c5", -"tsql": "c692d974ee3f362ecb38f27c" +"generic": "79278352c17c9de0f5a28af5", +"motherduck": "1ebac487198b6c90b027faab", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "79278352c17c9de0f5a28af5", +"postgresql": "79278352c17c9de0f5a28af5", +"snowflake": "97a20344d811fb77c7690863", +"tsql": "79278352c17c9de0f5a28af5" } ], [ "type", { "DuckDB": "1fe8a2d5a41383bd8e502808", -"None": "1fe8a2d5a41383bd8e502808", +"None": "70f3d045595fbd43219efb36", "bigquery": "70f3d045595fbd43219efb36", "databricks": "70f3d045595fbd43219efb36", "duckdb": "1fe8a2d5a41383bd8e502808", -"generic": "1fe8a2d5a41383bd8e502808", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70f3d045595fbd43219efb36", -"postgres": "1fe8a2d5a41383bd8e502808", -"postgresql": "1fe8a2d5a41383bd8e502808", +"generic": "70f3d045595fbd43219efb36", +"motherduck": "1fe8a2d5a41383bd8e502808", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3c17ab67cd8c034fc4911ef2", +"postgresql": "3c17ab67cd8c034fc4911ef2", "snowflake": "1fe8a2d5a41383bd8e502808", -"tsql": "1fe8a2d5a41383bd8e502808" +"tsql": "70f3d045595fbd43219efb36" } ], [ @@ -24573,8 +24573,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -24587,11 +24587,11 @@ "DuckDB": "035bb58fd2c7dca585a5899c", "None": "035bb58fd2c7dca585a5899c", "bigquery": "035bb58fd2c7dca585a5899c", -"databricks": "958e791772d9007024c889d3", +"databricks": "035bb58fd2c7dca585a5899c", "duckdb": "035bb58fd2c7dca585a5899c", "generic": "035bb58fd2c7dca585a5899c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "770b1d275ab7799c8484f304", +"motherduck": "035bb58fd2c7dca585a5899c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "035bb58fd2c7dca585a5899c", "postgresql": "035bb58fd2c7dca585a5899c", "snowflake": "035bb58fd2c7dca585a5899c", @@ -24602,34 +24602,34 @@ "type", { "DuckDB": "7515c0db413239044adef879", -"None": "7515c0db413239044adef879", -"bigquery": "f276e907770196606577c932", -"databricks": "7515c0db413239044adef879", +"None": "d4b89e61a66aeb076db92954", +"bigquery": "bb92c01c64d1a2d32abb67b5", +"databricks": "d4b89e61a66aeb076db92954", "duckdb": "7515c0db413239044adef879", -"generic": "7515c0db413239044adef879", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7515c0db413239044adef879", +"generic": "d4b89e61a66aeb076db92954", +"motherduck": "7515c0db413239044adef879", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "7515c0db413239044adef879", "postgresql": "7515c0db413239044adef879", "snowflake": "67b5874a2c569226c490211f", -"tsql": "7515c0db413239044adef879" +"tsql": "d4b89e61a66aeb076db92954" } ], [ "type", { "DuckDB": "a3b6b25265be330ec52a3322", -"None": "a3b6b25265be330ec52a3322", -"bigquery": "204206d1d1eecf007966cc5b", -"databricks": "e3bc1b8bad22d8104417b00f", +"None": "62368fc15cefd5807807b209", +"bigquery": "c50a316d091c821866e4bfba", +"databricks": "62368fc15cefd5807807b209", "duckdb": "a3b6b25265be330ec52a3322", -"generic": "a3b6b25265be330ec52a3322", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "919b7ec6a7b49d8527b784cd", -"postgres": "a3b6b25265be330ec52a3322", -"postgresql": "a3b6b25265be330ec52a3322", +"generic": "62368fc15cefd5807807b209", +"motherduck": "a3b6b25265be330ec52a3322", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "62368fc15cefd5807807b209", +"postgresql": "62368fc15cefd5807807b209", "snowflake": "919b7ec6a7b49d8527b784cd", -"tsql": "a3b6b25265be330ec52a3322" +"tsql": "62368fc15cefd5807807b209" } ], [ @@ -24641,8 +24641,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "d61c83ef8bfdf043fa672cb5", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "d61c83ef8bfdf043fa672cb5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -24658,8 +24658,8 @@ "databricks": "268b9b7c7862c9de6569286a", "duckdb": "268b9b7c7862c9de6569286a", "generic": "268b9b7c7862c9de6569286a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "268b9b7c7862c9de6569286a", +"motherduck": "268b9b7c7862c9de6569286a", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "268b9b7c7862c9de6569286a", "postgresql": "268b9b7c7862c9de6569286a", "snowflake": "268b9b7c7862c9de6569286a", @@ -24675,8 +24675,8 @@ "databricks": "b137c998bdaa2555d912e8fa", "duckdb": "27f973a6b2da27a79f5c0074", "generic": "b137c998bdaa2555d912e8fa", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b137c998bdaa2555d912e8fa", +"motherduck": "27f973a6b2da27a79f5c0074", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "b137c998bdaa2555d912e8fa", "postgresql": "b137c998bdaa2555d912e8fa", "snowflake": "b137c998bdaa2555d912e8fa", @@ -24686,16 +24686,16 @@ [ "type", { -"DuckDB": "4ed568ea1adb2c8a7141be20", -"None": "b981394a3f4d961a44e73868", -"bigquery": "f65845aac707b13992e53f87", -"databricks": "b981394a3f4d961a44e73868", -"duckdb": "4ed568ea1adb2c8a7141be20", -"generic": "b981394a3f4d961a44e73868", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", -"postgres": "4ed568ea1adb2c8a7141be20", -"postgresql": "4ed568ea1adb2c8a7141be20", +"DuckDB": "efd6c6e5ae853495e89afda4", +"None": "8e94482f81cd02e976359898", +"bigquery": "8e94482f81cd02e976359898", +"databricks": "8e94482f81cd02e976359898", +"duckdb": "efd6c6e5ae853495e89afda4", +"generic": "8e94482f81cd02e976359898", +"motherduck": "efd6c6e5ae853495e89afda4", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "efd6c6e5ae853495e89afda4", +"postgresql": "efd6c6e5ae853495e89afda4", "snowflake": "311749caf0bd53fee7b23fa1", "tsql": "8e94482f81cd02e976359898" } @@ -24709,8 +24709,8 @@ "databricks": "d5b8a68e96a7848f2aa7b2d6", "duckdb": "d5b8a68e96a7848f2aa7b2d6", "generic": "d5b8a68e96a7848f2aa7b2d6", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d5b8a68e96a7848f2aa7b2d6", +"motherduck": "d5b8a68e96a7848f2aa7b2d6", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d5b8a68e96a7848f2aa7b2d6", "postgresql": "d5b8a68e96a7848f2aa7b2d6", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -24726,8 +24726,8 @@ "databricks": "1fa913156c869f5373066b2b", "duckdb": "1fa913156c869f5373066b2b", "generic": "1fa913156c869f5373066b2b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1fa913156c869f5373066b2b", +"motherduck": "1fa913156c869f5373066b2b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1fa913156c869f5373066b2b", "postgresql": "1fa913156c869f5373066b2b", "snowflake": "1fa913156c869f5373066b2b", @@ -24743,10 +24743,10 @@ "databricks": "3673b4fbbd8a7fed7120ec2b", "duckdb": "3673b4fbbd8a7fed7120ec2b", "generic": "3673b4fbbd8a7fed7120ec2b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3673b4fbbd8a7fed7120ec2b", -"postgres": "3673b4fbbd8a7fed7120ec2b", -"postgresql": "3673b4fbbd8a7fed7120ec2b", +"motherduck": "3673b4fbbd8a7fed7120ec2b", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "9aff7fcc7d550e1a8d105471", +"postgresql": "9aff7fcc7d550e1a8d105471", "snowflake": "3673b4fbbd8a7fed7120ec2b", "tsql": "3673b4fbbd8a7fed7120ec2b" } @@ -24760,10 +24760,10 @@ "databricks": "7770c7aba92f1bba835ef3f8", "duckdb": "7770c7aba92f1bba835ef3f8", "generic": "7770c7aba92f1bba835ef3f8", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7770c7aba92f1bba835ef3f8", -"postgres": "7770c7aba92f1bba835ef3f8", -"postgresql": "7770c7aba92f1bba835ef3f8", +"motherduck": "7770c7aba92f1bba835ef3f8", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "55de7125c9ef4832b853c094", +"postgresql": "55de7125c9ef4832b853c094", "snowflake": "7770c7aba92f1bba835ef3f8", "tsql": "7770c7aba92f1bba835ef3f8" } @@ -24772,17 +24772,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -24794,8 +24794,8 @@ "databricks": "e57ac1541fb51b362cd5b470", "duckdb": "e57ac1541fb51b362cd5b470", "generic": "e57ac1541fb51b362cd5b470", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "e57ac1541fb51b362cd5b470", +"motherduck": "e57ac1541fb51b362cd5b470", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "e57ac1541fb51b362cd5b470", "postgresql": "e57ac1541fb51b362cd5b470", "snowflake": "4b356542044f1267fcfc487a", @@ -24805,18 +24805,18 @@ [ "type", { -"DuckDB": "436bf2624179c536a0157841", -"None": "3c6e55e3040bec9d73dd1bae", +"DuckDB": "4cce9f29790ed5c86ebce81d", +"None": "00e3060d99b1d939ec9f3616", "bigquery": "f1e1c64039c39ec114b5ede6", -"databricks": "21bc62fef8fe5716ed99f7be", -"duckdb": "436bf2624179c536a0157841", -"generic": "3c6e55e3040bec9d73dd1bae", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "3c6e55e3040bec9d73dd1bae", -"postgres": "8141c88dbee0d916c5447a97", -"postgresql": "8141c88dbee0d916c5447a97", +"databricks": "b1961f9482bbd04d61ba1c52", +"duckdb": "4cce9f29790ed5c86ebce81d", +"generic": "00e3060d99b1d939ec9f3616", +"motherduck": "4cce9f29790ed5c86ebce81d", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "6e5449b80c5f377b124fba88", +"postgresql": "6e5449b80c5f377b124fba88", "snowflake": "cfa49b8de6f3939e2701f38d", -"tsql": "28f1e600e17067938d8a74f4" +"tsql": "7755cfc984436641c774f231" } ], [ @@ -24824,12 +24824,12 @@ { "DuckDB": "431ce1fed4f6ce1e6c2a6479", "None": "6282d36888b8e0aadda09779", -"bigquery": "9da8d0485dcb32b3b63f0ed3", +"bigquery": "02e0b2ed25f32a8d09350a23", "databricks": "6282d36888b8e0aadda09779", "duckdb": "431ce1fed4f6ce1e6c2a6479", "generic": "6282d36888b8e0aadda09779", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "431ce1fed4f6ce1e6c2a6479", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "431ce1fed4f6ce1e6c2a6479", "postgresql": "431ce1fed4f6ce1e6c2a6479", "snowflake": "4ea9204c46e0ec4e3a94f672", @@ -24845,8 +24845,8 @@ "databricks": "9917d6c8c04307304904313b", "duckdb": "9917d6c8c04307304904313b", "generic": "9917d6c8c04307304904313b", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "9917d6c8c04307304904313b", +"motherduck": "9917d6c8c04307304904313b", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9917d6c8c04307304904313b", "postgresql": "9917d6c8c04307304904313b", "snowflake": "9917d6c8c04307304904313b", @@ -24862,8 +24862,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -24879,8 +24879,8 @@ "databricks": "0712c33a016f7dd6a37ee011", "duckdb": "0712c33a016f7dd6a37ee011", "generic": "0712c33a016f7dd6a37ee011", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0f3f17e0fe13c04b84ded556", +"motherduck": "0712c33a016f7dd6a37ee011", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0712c33a016f7dd6a37ee011", "postgresql": "0712c33a016f7dd6a37ee011", "snowflake": "0712c33a016f7dd6a37ee011", @@ -24892,14 +24892,14 @@ { "DuckDB": "fe23594c781e79cbb0c8927a", "None": "fe23594c781e79cbb0c8927a", -"bigquery": "fe23594c781e79cbb0c8927a", +"bigquery": "8a3f094f18fb4047f0febf59", "databricks": "fe23594c781e79cbb0c8927a", "duckdb": "fe23594c781e79cbb0c8927a", "generic": "fe23594c781e79cbb0c8927a", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fe23594c781e79cbb0c8927a", -"postgres": "fe23594c781e79cbb0c8927a", -"postgresql": "fe23594c781e79cbb0c8927a", +"motherduck": "fe23594c781e79cbb0c8927a", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "8a3f094f18fb4047f0febf59", +"postgresql": "8a3f094f18fb4047f0febf59", "snowflake": "38b2ec94bf02be40007ce525", "tsql": "fe23594c781e79cbb0c8927a" } @@ -24907,18 +24907,18 @@ [ "type", { -"DuckDB": "7fa8f60977ab1aa305af9d4b", -"None": "8c6ca3f77bf44837655a903e", -"bigquery": "89138ea06a52edf9b7991dd8", -"databricks": "3aa50c38af078e9f02f5a1c8", -"duckdb": "7fa8f60977ab1aa305af9d4b", -"generic": "8c6ca3f77bf44837655a903e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "8c6ca3f77bf44837655a903e", -"postgres": "8c6ca3f77bf44837655a903e", -"postgresql": "8c6ca3f77bf44837655a903e", +"DuckDB": "909ab87c62786e3181c86ba6", +"None": "22bed6e6de77311e5f24d414", +"bigquery": "22bed6e6de77311e5f24d414", +"databricks": "22bed6e6de77311e5f24d414", +"duckdb": "909ab87c62786e3181c86ba6", +"generic": "22bed6e6de77311e5f24d414", +"motherduck": "909ab87c62786e3181c86ba6", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "22bed6e6de77311e5f24d414", +"postgresql": "22bed6e6de77311e5f24d414", "snowflake": "05188197e056965f895710b0", -"tsql": "8c6ca3f77bf44837655a903e" +"tsql": "22bed6e6de77311e5f24d414" } ], [ @@ -24926,14 +24926,14 @@ { "DuckDB": "ee47e1424cb01deb0cf51760", "None": "ee47e1424cb01deb0cf51760", -"bigquery": "ee47e1424cb01deb0cf51760", +"bigquery": "893ff554934dfc6f8253597b", "databricks": "ee47e1424cb01deb0cf51760", "duckdb": "ee47e1424cb01deb0cf51760", "generic": "ee47e1424cb01deb0cf51760", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ee47e1424cb01deb0cf51760", -"postgres": "ee47e1424cb01deb0cf51760", -"postgresql": "ee47e1424cb01deb0cf51760", +"motherduck": "ee47e1424cb01deb0cf51760", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "3c1521654088dd54d0dc9ead", +"postgresql": "3c1521654088dd54d0dc9ead", "snowflake": "ee47e1424cb01deb0cf51760", "tsql": "ee47e1424cb01deb0cf51760" } @@ -24947,10 +24947,10 @@ "databricks": "49fdedaa5356fcccaa6f2f38", "duckdb": "49fdedaa5356fcccaa6f2f38", "generic": "49fdedaa5356fcccaa6f2f38", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "49fdedaa5356fcccaa6f2f38", -"postgres": "49fdedaa5356fcccaa6f2f38", -"postgresql": "49fdedaa5356fcccaa6f2f38", +"motherduck": "49fdedaa5356fcccaa6f2f38", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "cf14fd6412673db81925b3a0", +"postgresql": "cf14fd6412673db81925b3a0", "snowflake": "49fdedaa5356fcccaa6f2f38", "tsql": "49fdedaa5356fcccaa6f2f38" } @@ -24959,17 +24959,17 @@ "type", { "DuckDB": "70fb4728c3adcf6dbe4975d5", -"None": "70fb4728c3adcf6dbe4975d5", -"bigquery": "70fb4728c3adcf6dbe4975d5", -"databricks": "70fb4728c3adcf6dbe4975d5", +"None": "fb4b6f5101f973d16ea8d1f3", +"bigquery": "fb4b6f5101f973d16ea8d1f3", +"databricks": "fb4b6f5101f973d16ea8d1f3", "duckdb": "70fb4728c3adcf6dbe4975d5", -"generic": "70fb4728c3adcf6dbe4975d5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "70fb4728c3adcf6dbe4975d5", +"generic": "fb4b6f5101f973d16ea8d1f3", +"motherduck": "70fb4728c3adcf6dbe4975d5", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "70fb4728c3adcf6dbe4975d5", "postgresql": "70fb4728c3adcf6dbe4975d5", "snowflake": "70fb4728c3adcf6dbe4975d5", -"tsql": "70fb4728c3adcf6dbe4975d5" +"tsql": "fb4b6f5101f973d16ea8d1f3" } ], [ @@ -24981,10 +24981,10 @@ "databricks": "1e75e5227bea0ae294ac7af1", "duckdb": "19bdd92ea0cc5fb028657510", "generic": "b8321619b794db091c9e96a1", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "b8321619b794db091c9e96a1", -"postgres": "b8321619b794db091c9e96a1", -"postgresql": "b8321619b794db091c9e96a1", +"motherduck": "19bdd92ea0cc5fb028657510", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "bce26544873d6ec9191c9a86", +"postgresql": "bce26544873d6ec9191c9a86", "snowflake": "b8321619b794db091c9e96a1", "tsql": "b8321619b794db091c9e96a1" } @@ -24998,8 +24998,8 @@ "databricks": "46e6767a9ba2cc5fbfdc02d0", "duckdb": "9f79ba9960d200f49192fa87", "generic": "46e6767a9ba2cc5fbfdc02d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "6c03a3450ea4742ee7396e3c", +"motherduck": "9f79ba9960d200f49192fa87", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "9f79ba9960d200f49192fa87", "postgresql": "9f79ba9960d200f49192fa87", "snowflake": "72c40a5d469c974c1952c3c2", @@ -25015,8 +25015,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -25032,8 +25032,8 @@ "databricks": "d61c83ef8bfdf043fa672cb5", "duckdb": "305aaf0b95cee629dd46380c", "generic": "d61c83ef8bfdf043fa672cb5", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "d61c83ef8bfdf043fa672cb5", +"motherduck": "305aaf0b95cee629dd46380c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "d61c83ef8bfdf043fa672cb5", "postgresql": "d61c83ef8bfdf043fa672cb5", "snowflake": "97a20344d811fb77c7690863", @@ -25049,8 +25049,8 @@ "databricks": "0dc0164f07551711f23943eb", "duckdb": "0dc0164f07551711f23943eb", "generic": "0dc0164f07551711f23943eb", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0dc0164f07551711f23943eb", +"motherduck": "0dc0164f07551711f23943eb", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0dc0164f07551711f23943eb", "postgresql": "0dc0164f07551711f23943eb", "snowflake": "0dc0164f07551711f23943eb", @@ -25066,8 +25066,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", @@ -25079,12 +25079,12 @@ { "DuckDB": "0f799a95a4f5ef502897f02c", "None": "0f799a95a4f5ef502897f02c", -"bigquery": "b1b23029bedaa16e2a6f8516", +"bigquery": "1e75e5227bea0ae294ac7af1", "databricks": "0f799a95a4f5ef502897f02c", "duckdb": "0f799a95a4f5ef502897f02c", "generic": "0f799a95a4f5ef502897f02c", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0f799a95a4f5ef502897f02c", +"motherduck": "0f799a95a4f5ef502897f02c", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0f799a95a4f5ef502897f02c", "postgresql": "0f799a95a4f5ef502897f02c", "snowflake": "0f799a95a4f5ef502897f02c", @@ -25100,8 +25100,8 @@ "databricks": "2bfa352725f9d8a91250f75e", "duckdb": "2bfa352725f9d8a91250f75e", "generic": "2bfa352725f9d8a91250f75e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2bfa352725f9d8a91250f75e", +"motherduck": "2bfa352725f9d8a91250f75e", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "2bfa352725f9d8a91250f75e", "postgresql": "2bfa352725f9d8a91250f75e", "snowflake": "2bfa352725f9d8a91250f75e", @@ -25113,12 +25113,12 @@ { "DuckDB": "bda0c90e573c6a01b55627e2", "None": "bda0c90e573c6a01b55627e2", -"bigquery": "bda0c90e573c6a01b55627e2", +"bigquery": "0017a88bb60ec3403c786ed8", "databricks": "bda0c90e573c6a01b55627e2", "duckdb": "bda0c90e573c6a01b55627e2", "generic": "bda0c90e573c6a01b55627e2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "bda0c90e573c6a01b55627e2", +"motherduck": "bda0c90e573c6a01b55627e2", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "bda0c90e573c6a01b55627e2", "postgresql": "bda0c90e573c6a01b55627e2", "snowflake": "bda0c90e573c6a01b55627e2", @@ -25134,10 +25134,10 @@ "databricks": "2705f19942a4194a72576911", "duckdb": "2705f19942a4194a72576911", "generic": "2705f19942a4194a72576911", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "2705f19942a4194a72576911", -"postgres": "2705f19942a4194a72576911", -"postgresql": "2705f19942a4194a72576911", +"motherduck": "2705f19942a4194a72576911", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "5226d7e2a62c7650a87d6e84", +"postgresql": "5226d7e2a62c7650a87d6e84", "snowflake": "2705f19942a4194a72576911", "tsql": "2705f19942a4194a72576911" } @@ -25147,12 +25147,12 @@ { "DuckDB": "558da38ec4d9d5d6c72f60cf", "None": "558da38ec4d9d5d6c72f60cf", -"bigquery": "e6ffdece2977be55da73b59a", +"bigquery": "c50a316d091c821866e4bfba", "databricks": "558da38ec4d9d5d6c72f60cf", "duckdb": "558da38ec4d9d5d6c72f60cf", "generic": "558da38ec4d9d5d6c72f60cf", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "558da38ec4d9d5d6c72f60cf", +"motherduck": "558da38ec4d9d5d6c72f60cf", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "558da38ec4d9d5d6c72f60cf", "postgresql": "558da38ec4d9d5d6c72f60cf", "snowflake": "558da38ec4d9d5d6c72f60cf", @@ -25163,17 +25163,17 @@ "type", { "DuckDB": "314ed506f24e92300a425780", -"None": "314ed506f24e92300a425780", -"bigquery": "314ed506f24e92300a425780", -"databricks": "314ed506f24e92300a425780", +"None": "9a66317fb8d040bf991502c0", +"bigquery": "9bafb08d41fd1c208b5deca4", +"databricks": "9a66317fb8d040bf991502c0", "duckdb": "314ed506f24e92300a425780", -"generic": "314ed506f24e92300a425780", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "314ed506f24e92300a425780", +"generic": "9a66317fb8d040bf991502c0", +"motherduck": "314ed506f24e92300a425780", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "314ed506f24e92300a425780", "postgresql": "314ed506f24e92300a425780", "snowflake": "314ed506f24e92300a425780", -"tsql": "314ed506f24e92300a425780" +"tsql": "9a66317fb8d040bf991502c0" } ], [ @@ -25185,8 +25185,8 @@ "databricks": "0b8ad171901cc2b7725617da", "duckdb": "0b8ad171901cc2b7725617da", "generic": "0b8ad171901cc2b7725617da", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0b8ad171901cc2b7725617da", +"motherduck": "0b8ad171901cc2b7725617da", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0b8ad171901cc2b7725617da", "postgresql": "0b8ad171901cc2b7725617da", "snowflake": "0b8ad171901cc2b7725617da", @@ -25197,17 +25197,17 @@ "type", { "DuckDB": "363159f251e264604338e690", -"None": "363159f251e264604338e690", -"bigquery": "363159f251e264604338e690", -"databricks": "363159f251e264604338e690", +"None": "9a63ad6168418af23d9b6fd1", +"bigquery": "8b8d5f75ba6dec68b4cebc6b", +"databricks": "9a63ad6168418af23d9b6fd1", "duckdb": "363159f251e264604338e690", -"generic": "363159f251e264604338e690", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "363159f251e264604338e690", -"postgres": "363159f251e264604338e690", -"postgresql": "363159f251e264604338e690", +"generic": "9a63ad6168418af23d9b6fd1", +"motherduck": "363159f251e264604338e690", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f276e907770196606577c932", +"postgresql": "f276e907770196606577c932", "snowflake": "363159f251e264604338e690", -"tsql": "363159f251e264604338e690" +"tsql": "9a63ad6168418af23d9b6fd1" } ], [ @@ -25219,8 +25219,8 @@ "databricks": "e3bc1b8bad22d8104417b00f", "duckdb": "1d8b945fd793ecdcacb90c21", "generic": "1d8b945fd793ecdcacb90c21", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1d8b945fd793ecdcacb90c21", +"motherduck": "1d8b945fd793ecdcacb90c21", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "3efe8bb57c98fcbe74096b3c", "postgresql": "3efe8bb57c98fcbe74096b3c", "snowflake": "1d8b945fd793ecdcacb90c21", @@ -25236,8 +25236,8 @@ "databricks": "52c81331cf7cf6b56395e239", "duckdb": "52c81331cf7cf6b56395e239", "generic": "52c81331cf7cf6b56395e239", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "52c81331cf7cf6b56395e239", +"motherduck": "52c81331cf7cf6b56395e239", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "52c81331cf7cf6b56395e239", "postgresql": "52c81331cf7cf6b56395e239", "snowflake": "52c81331cf7cf6b56395e239", @@ -25253,8 +25253,8 @@ "databricks": "ebc821a95b9286e22c2b26d0", "duckdb": "ebc821a95b9286e22c2b26d0", "generic": "ebc821a95b9286e22c2b26d0", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "ebc821a95b9286e22c2b26d0", +"motherduck": "ebc821a95b9286e22c2b26d0", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "ebc821a95b9286e22c2b26d0", "postgresql": "ebc821a95b9286e22c2b26d0", "snowflake": "ebc821a95b9286e22c2b26d0", @@ -25270,8 +25270,8 @@ "databricks": "85569b6cabaea71507846025", "duckdb": "85569b6cabaea71507846025", "generic": "85569b6cabaea71507846025", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "85569b6cabaea71507846025", +"motherduck": "85569b6cabaea71507846025", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "85569b6cabaea71507846025", "postgresql": "85569b6cabaea71507846025", "snowflake": "85569b6cabaea71507846025", @@ -25287,10 +25287,10 @@ "databricks": "7f7363467010768b3de8fe05", "duckdb": "7f7363467010768b3de8fe05", "generic": "7f7363467010768b3de8fe05", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "7f7363467010768b3de8fe05", -"postgres": "7f7363467010768b3de8fe05", -"postgresql": "7f7363467010768b3de8fe05", +"motherduck": "7f7363467010768b3de8fe05", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "039da801fa79cb9eabce307d", +"postgresql": "039da801fa79cb9eabce307d", "snowflake": "7f7363467010768b3de8fe05", "tsql": "7f7363467010768b3de8fe05" } @@ -25304,8 +25304,8 @@ "databricks": "cc5643d29bc94cb1374704e9", "duckdb": "cc5643d29bc94cb1374704e9", "generic": "cc5643d29bc94cb1374704e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "cc5643d29bc94cb1374704e9", +"motherduck": "cc5643d29bc94cb1374704e9", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "cc5643d29bc94cb1374704e9", "postgresql": "cc5643d29bc94cb1374704e9", "snowflake": "cc5643d29bc94cb1374704e9", @@ -25321,8 +25321,8 @@ "databricks": "c50a316d091c821866e4bfba", "duckdb": "c50a316d091c821866e4bfba", "generic": "c50a316d091c821866e4bfba", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c50a316d091c821866e4bfba", +"motherduck": "c50a316d091c821866e4bfba", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "c50a316d091c821866e4bfba", "postgresql": "c50a316d091c821866e4bfba", "snowflake": "c50a316d091c821866e4bfba", @@ -25338,10 +25338,10 @@ "databricks": "c91ea1fc2032c6f196132d1e", "duckdb": "c91ea1fc2032c6f196132d1e", "generic": "c91ea1fc2032c6f196132d1e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "c91ea1fc2032c6f196132d1e", -"postgres": "c91ea1fc2032c6f196132d1e", -"postgresql": "c91ea1fc2032c6f196132d1e", +"motherduck": "c91ea1fc2032c6f196132d1e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "652ff8b21f638eac8fdc46c5", +"postgresql": "652ff8b21f638eac8fdc46c5", "snowflake": "c91ea1fc2032c6f196132d1e", "tsql": "c91ea1fc2032c6f196132d1e" } @@ -25352,11 +25352,11 @@ "DuckDB": "87496ad15619ba3d233601ad", "None": "87496ad15619ba3d233601ad", "bigquery": "87496ad15619ba3d233601ad", -"databricks": "5878645b159a4a60df8c2681", +"databricks": "87496ad15619ba3d233601ad", "duckdb": "87496ad15619ba3d233601ad", "generic": "87496ad15619ba3d233601ad", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "675e09f896465856e2673811", +"motherduck": "87496ad15619ba3d233601ad", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "87496ad15619ba3d233601ad", "postgresql": "87496ad15619ba3d233601ad", "snowflake": "87496ad15619ba3d233601ad", @@ -25367,17 +25367,17 @@ "type", { "DuckDB": "23f70cb2333740d79361d52e", -"None": "23f70cb2333740d79361d52e", -"bigquery": "816384049477221b0a4a5b89", -"databricks": "23f70cb2333740d79361d52e", +"None": "a33d60d9b009878ab623c1d8", +"bigquery": "bb92c01c64d1a2d32abb67b5", +"databricks": "a33d60d9b009878ab623c1d8", "duckdb": "23f70cb2333740d79361d52e", -"generic": "23f70cb2333740d79361d52e", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "23f70cb2333740d79361d52e", -"postgres": "23f70cb2333740d79361d52e", -"postgresql": "23f70cb2333740d79361d52e", +"generic": "a33d60d9b009878ab623c1d8", +"motherduck": "23f70cb2333740d79361d52e", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "f276e907770196606577c932", +"postgresql": "f276e907770196606577c932", "snowflake": "23f70cb2333740d79361d52e", -"tsql": "23f70cb2333740d79361d52e" +"tsql": "a33d60d9b009878ab623c1d8" } ], [ @@ -25389,8 +25389,8 @@ "databricks": "1eb7fb4e8cf75773c5573562", "duckdb": "1eb7fb4e8cf75773c5573562", "generic": "1eb7fb4e8cf75773c5573562", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "1eb7fb4e8cf75773c5573562", +"motherduck": "1eb7fb4e8cf75773c5573562", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "1eb7fb4e8cf75773c5573562", "postgresql": "1eb7fb4e8cf75773c5573562", "snowflake": "97a20344d811fb77c7690863", @@ -25406,8 +25406,8 @@ "databricks": "300e2b67af892b463d85f9cd", "duckdb": "300e2b67af892b463d85f9cd", "generic": "300e2b67af892b463d85f9cd", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "300e2b67af892b463d85f9cd", +"motherduck": "300e2b67af892b463d85f9cd", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "300e2b67af892b463d85f9cd", "postgresql": "300e2b67af892b463d85f9cd", "snowflake": "300e2b67af892b463d85f9cd", @@ -25423,10 +25423,10 @@ "databricks": "669084d1ea704ae5b8ee05c2", "duckdb": "669084d1ea704ae5b8ee05c2", "generic": "669084d1ea704ae5b8ee05c2", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "669084d1ea704ae5b8ee05c2", -"postgres": "669084d1ea704ae5b8ee05c2", -"postgresql": "669084d1ea704ae5b8ee05c2", +"motherduck": "669084d1ea704ae5b8ee05c2", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "93c1b5b5960e26479baf88d0", +"postgresql": "93c1b5b5960e26479baf88d0", "snowflake": "669084d1ea704ae5b8ee05c2", "tsql": "669084d1ea704ae5b8ee05c2" } @@ -25436,14 +25436,14 @@ { "DuckDB": "08736485547ba339930697e9", "None": "08736485547ba339930697e9", -"bigquery": "08736485547ba339930697e9", +"bigquery": "837468174ef3e5cb4e4b4070", "databricks": "08736485547ba339930697e9", "duckdb": "08736485547ba339930697e9", "generic": "08736485547ba339930697e9", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "08736485547ba339930697e9", -"postgres": "08736485547ba339930697e9", -"postgresql": "08736485547ba339930697e9", +"motherduck": "08736485547ba339930697e9", +"mysql": "9565c6d3005d7730ba35e40b", +"postgres": "eecd452b4f5f3f4133d0bd0a", +"postgresql": "eecd452b4f5f3f4133d0bd0a", "snowflake": "08736485547ba339930697e9", "tsql": "08736485547ba339930697e9" } @@ -25457,8 +25457,8 @@ "databricks": "0c4610f182f18bf41d306e01", "duckdb": "0c4610f182f18bf41d306e01", "generic": "0c4610f182f18bf41d306e01", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "0c4610f182f18bf41d306e01", +"motherduck": "0c4610f182f18bf41d306e01", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "0c4610f182f18bf41d306e01", "postgresql": "0c4610f182f18bf41d306e01", "snowflake": "0c4610f182f18bf41d306e01", @@ -25474,8 +25474,8 @@ "databricks": "fad6caec1e65529a6edc32df", "duckdb": "fad6caec1e65529a6edc32df", "generic": "fad6caec1e65529a6edc32df", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "fad6caec1e65529a6edc32df", +"motherduck": "fad6caec1e65529a6edc32df", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "fad6caec1e65529a6edc32df", "postgresql": "fad6caec1e65529a6edc32df", "snowflake": "fad6caec1e65529a6edc32df", @@ -25491,8 +25491,8 @@ "databricks": "a428302e4848ffe877284c84", "duckdb": "a428302e4848ffe877284c84", "generic": "a428302e4848ffe877284c84", -"motherduck": "901c5133ed47d4769286e860", -"mysql": "a428302e4848ffe877284c84", +"motherduck": "a428302e4848ffe877284c84", +"mysql": "9565c6d3005d7730ba35e40b", "postgres": "a428302e4848ffe877284c84", "postgresql": "a428302e4848ffe877284c84", "snowflake": "652ff8b21f638eac8fdc46c5", diff --git a/tests/integration/src/sqlbuild/adapter/type_system/_test_types.py b/tests/integration/src/sqlbuild/adapter/type_system/_test_types.py index 858a2dee8e..89beb07f70 100644 --- a/tests/integration/src/sqlbuild/adapter/type_system/_test_types.py +++ b/tests/integration/src/sqlbuild/adapter/type_system/_test_types.py @@ -33,7 +33,7 @@ class TypeNormalizationTestCase: @dataclass(frozen=True) class UnknownDialectTypeTestCase: - """A dialect Polyglot does not know, and the error Python's wheel raised for it.""" + """A dialect SQLBuild has no type rules for, and the error normalization raises for it.""" description: str dialect: str diff --git a/tests/integration/src/sqlbuild/adapter/type_system/helpers.py b/tests/integration/src/sqlbuild/adapter/type_system/helpers.py index fba51cf622..2d019de5d1 100644 --- a/tests/integration/src/sqlbuild/adapter/type_system/helpers.py +++ b/tests/integration/src/sqlbuild/adapter/type_system/helpers.py @@ -168,7 +168,7 @@ def is_normalized(outcome: TypeOutcome) -> bool: def logged_parse_error(outcome: TypeOutcome) -> bool: - """Return whether a Polyglot parse failure was logged for this type.""" + """Return whether a type parse failure was logged for this type.""" return bool(outcome.logged_errors) diff --git a/tests/integration/src/sqlbuild/adapter/type_system/test_native_type_normalization.py b/tests/integration/src/sqlbuild/adapter/type_system/test_native_type_normalization.py index 79cb00a903..bbd2847af9 100644 --- a/tests/integration/src/sqlbuild/adapter/type_system/test_native_type_normalization.py +++ b/tests/integration/src/sqlbuild/adapter/type_system/test_native_type_normalization.py @@ -213,9 +213,9 @@ def test_given_generated_types_when_normalizing_then_every_known_dialect_answers expected_parse_error_logged=True, ), TypeNormalizationTestCase( - description="a dialect outside the old native build", + description="MotherDuck reads types as DuckDB", type_sql="INT", - dialect="mysql", + dialect="motherduck", expected_type=NormalizedType(normalized_name="INT", family=TypeFamily.INTEGER), expected_parse_error_logged=False, ), @@ -244,9 +244,9 @@ def test_given_type_when_normalizing_then_python_shape_is_returned( "test_case", [ UnknownDialectTypeTestCase( - description="a dialect name Polyglot does not know", - dialect="motherduck", - expected_error="ValueError: Unknown dialect: motherduck", + description="a dialect no SQLBuild adapter ships", + dialect="mysql", + expected_error="ValueError: Unknown dialect: mysql", ), ], ids=lambda case: case.description, diff --git a/tests/integration/src/sqlbuild/compiler/contracts/test_native_model_contracts.py b/tests/integration/src/sqlbuild/compiler/contracts/test_native_model_contracts.py index f7e8c93063..3d5658116a 100644 --- a/tests/integration/src/sqlbuild/compiler/contracts/test_native_model_contracts.py +++ b/tests/integration/src/sqlbuild/compiler/contracts/test_native_model_contracts.py @@ -128,9 +128,9 @@ def test_given_generated_contracts_when_validating_then_every_contract_family_is ), ), FormerlyDeferredContractTestCase( - description="a dialect outside the old native build", + description="a shipped dialect without a native type parser", declared_type="INTEGER", - dialect="mysql", + dialect="tsql", expected_diagnostics=( ( "K002", @@ -184,9 +184,9 @@ def test_given_input_python_once_answered_when_validating_then_native_diagnostic "test_case", [ UnknownDialectContractTestCase( - description="a dialect Polyglot does not know raises the wheel's error", - dialect="motherduck", - expected_error="Unknown dialect: motherduck", + description="a dialect no adapter ships raises the wheel's error", + dialect="mysql", + expected_error="Unknown dialect: mysql", ), ], ids=lambda case: case.description, diff --git a/tests/integration/src/sqlbuild/compiler/semantic_checks/test_native_metadata_checks.py b/tests/integration/src/sqlbuild/compiler/semantic_checks/test_native_metadata_checks.py index de7023ba50..21389df895 100644 --- a/tests/integration/src/sqlbuild/compiler/semantic_checks/test_native_metadata_checks.py +++ b/tests/integration/src/sqlbuild/compiler/semantic_checks/test_native_metadata_checks.py @@ -56,7 +56,7 @@ seed=20261017, count=4, model_count=10, - dialects=("duckdb", "mysql", "tsql", None, "nonsense"), + dialects=("duckdb", "clickhouse", "tsql", None, "nonsense"), non_ascii=True, golden_prefix="metadata_formerly_deferred", expected_minimum_native=12, diff --git a/tests/integration/src/sqlbuild/compiler/semantic_checks/test_native_semantic_checks.py b/tests/integration/src/sqlbuild/compiler/semantic_checks/test_native_semantic_checks.py index 1f2c4f7dcb..d7d5d1d6dd 100644 --- a/tests/integration/src/sqlbuild/compiler/semantic_checks/test_native_semantic_checks.py +++ b/tests/integration/src/sqlbuild/compiler/semantic_checks/test_native_semantic_checks.py @@ -132,7 +132,7 @@ def test_given_generated_failing_projects_when_completing_natively_then_matches_ seed=20261015, count=2, non_ascii=False, - dialects=("mysql", "tsql", "databricks", "sqlite", "oracle", "trino"), + dialects=("tsql", "databricks", "sqlite", "clickhouse"), expected_outcomes=frozenset({"completed"}), ), FormerlyDeferredSemanticTestCase(