polyglot-sql 0.3.6__tar.gz → 0.3.9__tar.gz

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.3.6"
+version = "0.3.9"
 dependencies = [
  "criterion",
  "once_cell",
@@ -621,7 +621,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.3.6"
+version = "0.3.9"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -631,11 +631,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.3.6"
+version = "0.3.9"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.3.6"
+version = "0.3.9"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.3.6"
+version = "0.3.9"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.3.6"
+version = "0.3.9"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.3.6
+Version: 0.3.9
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/crates/polyglot-sql/Cargo.toml

@@ -83,7 +83,7 @@ thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.3.6", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.3.9", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/builder.rs

@@ -294,6 +294,8 @@ pub fn alias(expr: Expr, name: &str) -> Expr {
         this: expr.0,
         alias: builder_identifier(name),
         column_aliases: Vec::new(),
+        alias_explicit_as: false,
+        alias_keyword: None,
         pre_alias_comments: Vec::new(),
         trailing_comments: Vec::new(),
         inferred_type: None,
@@ -1955,6 +1957,8 @@ pub fn subquery_expr(expr: Expression, alias_name: &str) -> Expr {
         this: expr,
         alias: Some(builder_identifier(alias_name)),
         column_aliases: Vec::new(),
+        alias_explicit_as: false,
+        alias_keyword: None,
         order_by: None,
         limit: None,
         offset: None,

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -683,6 +683,8 @@ impl DialectImpl for BigQueryDialect {
                     this: unnest,
                     alias: Identifier::new("_col"),
                     column_aliases: Vec::new(),
+                    alias_explicit_as: false,
+                    alias_keyword: None,
                     pre_alias_comments: Vec::new(),
                     trailing_comments: Vec::new(),
                     inferred_type: None,

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/dialects/clickhouse.rs

@@ -42,6 +42,10 @@ impl DialectImpl for ClickHouseDialect {
         config.hex_string_is_integer_type = true;
         // ClickHouse allows underscores as digit separators in numeric literals
         config.numbers_can_be_underscore_separated = true;
+        // SQLGlot tokenizes malformed SHOW LIKE probes such as `'a\' or 1=1`.
+        config.recover_terminal_backslash_quote = true;
+        // The ClickHouse corpus includes partial string probes extracted from shell tests.
+        config.recover_unterminated_string = true;
         config
     }
 
@@ -249,6 +253,12 @@ impl DialectImpl for ClickHouseDialect {
             // IF(cond, true, false) -> CASE WHEN cond THEN true ELSE false END
             Expression::IfFunc(f) => {
                 let f = *f;
+                let has_aliased_arg = matches!(f.condition, Expression::Alias(_))
+                    || matches!(f.true_value, Expression::Alias(_))
+                    || matches!(f.false_value.as_ref(), Some(Expression::Alias(_)));
+                if has_aliased_arg {
+                    return Ok(Expression::IfFunc(Box::new(f)));
+                }
                 Ok(Expression::Case(Box::new(Case {
                     operand: None,
                     whens: vec![(f.condition, f.true_value)],

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/dialects/databricks.rs

@@ -225,6 +225,8 @@ impl DatabricksDialect {
                                     this: pair[1].clone(),
                                     alias: crate::expressions::Identifier::new(field_name),
                                     column_aliases: Vec::new(),
+                                    alias_explicit_as: false,
+                                    alias_keyword: None,
                                     pre_alias_comments: Vec::new(),
                                     trailing_comments: Vec::new(),
                                     inferred_type: None,

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -1212,6 +1212,8 @@ impl DialectImpl for DuckDBDialect {
                                         this: value,
                                         alias,
                                         column_aliases: Vec::new(),
+                                        alias_explicit_as: false,
+                                        alias_keyword: None,
                                         pre_alias_comments: Vec::new(),
                                         trailing_comments: Vec::new(),
                                         inferred_type: None,
@@ -1418,6 +1420,8 @@ impl DuckDBDialect {
                             this: stmt,
                             alias: None,
                             column_aliases: Vec::new(),
+                            alias_explicit_as: false,
+                            alias_keyword: None,
                             order_by: None,
                             limit: None,
                             offset: None,

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/dialects/mod.rs

@@ -158,7 +158,10 @@ pub use trino::TrinoDialect;
 pub use tsql::TSQLDialect;
 
 use crate::error::Result;
-use crate::expressions::{Expression, Function, FunctionBody, Identifier, Null};
+use crate::expressions::{
+    Expression, From, Function, FunctionBody, Identifier, Join, Null, OrderBy, OutputClause,
+    TableRef, With,
+};
 use crate::generator::{Generator, GeneratorConfig};
 use crate::parser::Parser;
 use crate::tokens::{Token, TokenType, Tokenizer, TokenizerConfig};
@@ -1661,6 +1664,122 @@ where
     }
 }
 
+fn transform_table_ref_recursive<F>(table: TableRef, transform_fn: &F) -> Result<TableRef>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    match transform_recursive(Expression::Table(Box::new(table)), transform_fn)? {
+        Expression::Table(table) => Ok(*table),
+        _ => Err(crate::error::Error::parse(
+            "TableRef transformation returned non-table expression",
+            0,
+            0,
+            0,
+            0,
+        )),
+    }
+}
+
+fn transform_from_recursive<F>(from: From, transform_fn: &F) -> Result<From>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    match transform_recursive(Expression::From(Box::new(from)), transform_fn)? {
+        Expression::From(from) => Ok(*from),
+        _ => Err(crate::error::Error::parse(
+            "FROM transformation returned non-FROM expression",
+            0,
+            0,
+            0,
+            0,
+        )),
+    }
+}
+
+fn transform_join_recursive<F>(mut join: Join, transform_fn: &F) -> Result<Join>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    join.this = transform_recursive(join.this, transform_fn)?;
+    if let Some(on) = join.on.take() {
+        join.on = Some(transform_recursive(on, transform_fn)?);
+    }
+    if let Some(match_condition) = join.match_condition.take() {
+        join.match_condition = Some(transform_recursive(match_condition, transform_fn)?);
+    }
+    join.pivots = join
+        .pivots
+        .into_iter()
+        .map(|pivot| transform_recursive(pivot, transform_fn))
+        .collect::<Result<Vec<_>>>()?;
+
+    match transform_fn(Expression::Join(Box::new(join)))? {
+        Expression::Join(join) => Ok(*join),
+        _ => Err(crate::error::Error::parse(
+            "Join transformation returned non-join expression",
+            0,
+            0,
+            0,
+            0,
+        )),
+    }
+}
+
+fn transform_output_clause_recursive<F>(
+    mut output: OutputClause,
+    transform_fn: &F,
+) -> Result<OutputClause>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    output.columns = output
+        .columns
+        .into_iter()
+        .map(|column| transform_recursive(column, transform_fn))
+        .collect::<Result<Vec<_>>>()?;
+    if let Some(into_table) = output.into_table.take() {
+        output.into_table = Some(transform_recursive(into_table, transform_fn)?);
+    }
+    Ok(output)
+}
+
+fn transform_with_recursive<F>(mut with: With, transform_fn: &F) -> Result<With>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    with.ctes = with
+        .ctes
+        .into_iter()
+        .map(|mut cte| {
+            cte.this = transform_recursive(cte.this, transform_fn)?;
+            Ok(cte)
+        })
+        .collect::<Result<Vec<_>>>()?;
+    if let Some(search) = with.search.take() {
+        with.search = Some(Box::new(transform_recursive(*search, transform_fn)?));
+    }
+    Ok(with)
+}
+
+fn transform_order_by_recursive<F>(mut order: OrderBy, transform_fn: &F) -> Result<OrderBy>
+where
+    F: Fn(Expression) -> Result<Expression>,
+{
+    order.expressions = order
+        .expressions
+        .into_iter()
+        .map(|mut ordered| {
+            let original = ordered.this.clone();
+            ordered.this = transform_recursive(ordered.this, transform_fn).unwrap_or(original);
+            match transform_fn(Expression::Ordered(Box::new(ordered.clone()))) {
+                Ok(Expression::Ordered(transformed)) => Ok(*transformed),
+                Ok(_) | Err(_) => Ok(ordered),
+            }
+        })
+        .collect::<Result<Vec<_>>>()?;
+    Ok(order)
+}
+
 fn transform_recursive_reference<F>(expr: Expression, transform_fn: &F) -> Result<Expression>
 where
     F: Fn(Expression) -> Result<Expression>,
@@ -2377,6 +2496,17 @@ where
             Expression::Insert(ins)
         }
         Expression::Update(mut upd) => {
+            upd.table = transform_table_ref_recursive(upd.table, transform_fn)?;
+            upd.extra_tables = upd
+                .extra_tables
+                .into_iter()
+                .map(|table| transform_table_ref_recursive(table, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
+            upd.table_joins = upd
+                .table_joins
+                .into_iter()
+                .map(|join| transform_join_recursive(join, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
             upd.set = upd
                 .set
                 .into_iter()
@@ -2385,17 +2515,75 @@ where
                     (id, new_val)
                 })
                 .collect();
+            if let Some(from_clause) = upd.from_clause.take() {
+                upd.from_clause = Some(transform_from_recursive(from_clause, transform_fn)?);
+            }
+            upd.from_joins = upd
+                .from_joins
+                .into_iter()
+                .map(|join| transform_join_recursive(join, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
             if let Some(mut where_clause) = upd.where_clause.take() {
                 where_clause.this = transform_recursive(where_clause.this, transform_fn)?;
                 upd.where_clause = Some(where_clause);
             }
+            upd.returning = upd
+                .returning
+                .into_iter()
+                .map(|expr| transform_recursive(expr, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
+            if let Some(output) = upd.output.take() {
+                upd.output = Some(transform_output_clause_recursive(output, transform_fn)?);
+            }
+            if let Some(with) = upd.with.take() {
+                upd.with = Some(transform_with_recursive(with, transform_fn)?);
+            }
+            if let Some(limit) = upd.limit.take() {
+                upd.limit = Some(transform_recursive(limit, transform_fn)?);
+            }
+            if let Some(order_by) = upd.order_by.take() {
+                upd.order_by = Some(transform_order_by_recursive(order_by, transform_fn)?);
+            }
             Expression::Update(upd)
         }
         Expression::Delete(mut del) => {
+            del.table = transform_table_ref_recursive(del.table, transform_fn)?;
+            del.using = del
+                .using
+                .into_iter()
+                .map(|table| transform_table_ref_recursive(table, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
             if let Some(mut where_clause) = del.where_clause.take() {
                 where_clause.this = transform_recursive(where_clause.this, transform_fn)?;
                 del.where_clause = Some(where_clause);
             }
+            if let Some(output) = del.output.take() {
+                del.output = Some(transform_output_clause_recursive(output, transform_fn)?);
+            }
+            if let Some(with) = del.with.take() {
+                del.with = Some(transform_with_recursive(with, transform_fn)?);
+            }
+            if let Some(limit) = del.limit.take() {
+                del.limit = Some(transform_recursive(limit, transform_fn)?);
+            }
+            if let Some(order_by) = del.order_by.take() {
+                del.order_by = Some(transform_order_by_recursive(order_by, transform_fn)?);
+            }
+            del.returning = del
+                .returning
+                .into_iter()
+                .map(|expr| transform_recursive(expr, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
+            del.tables = del
+                .tables
+                .into_iter()
+                .map(|table| transform_table_ref_recursive(table, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
+            del.joins = del
+                .joins
+                .into_iter()
+                .map(|join| transform_join_recursive(join, transform_fn))
+                .collect::<Result<Vec<_>>>()?;
             Expression::Delete(del)
         }
 
@@ -4605,6 +4793,8 @@ impl Dialect {
                     Identifier::new(&alias_name),
                     Identifier::new("this"),
                 ],
+                alias_explicit_as: false,
+                alias_keyword: None,
                 pre_alias_comments: vec![],
                 trailing_comments: vec![],
                 inferred_type: None,
@@ -4695,6 +4885,8 @@ impl Dialect {
                     this: dateadd.clone(),
                     alias: Identifier::new(alias_name),
                     column_aliases: vec![],
+                    alias_explicit_as: false,
+                    alias_keyword: None,
                     pre_alias_comments: vec![],
                     trailing_comments: vec![],
                     inferred_type: None,
@@ -4707,6 +4899,8 @@ impl Dialect {
                     this: new_this,
                     alias: a.alias.clone(),
                     column_aliases: a.column_aliases.clone(),
+                    alias_explicit_as: false,
+                    alias_keyword: None,
                     pre_alias_comments: a.pre_alias_comments.clone(),
                     trailing_comments: a.trailing_comments.clone(),
                     inferred_type: None,
@@ -4916,6 +5110,8 @@ impl Dialect {
                 Identifier::new(&col_name),
                 Identifier::new("this"),
             ],
+            alias_explicit_as: false,
+            alias_keyword: None,
             pre_alias_comments: vec![],
             trailing_comments: vec![],
             inferred_type: None,
@@ -4960,6 +5156,8 @@ impl Dialect {
             this: dateadd_expr,
             alias: Identifier::new(&col_name),
             column_aliases: vec![],
+            alias_explicit_as: false,
+            alias_keyword: None,
             pre_alias_comments: vec![],
             trailing_comments: vec![],
             inferred_type: None,
@@ -4977,6 +5175,8 @@ impl Dialect {
             this: inner_select_expr,
             alias: None,
             column_aliases: vec![],
+            alias_explicit_as: false,
+            alias_keyword: None,
             order_by: None,
             limit: None,
             offset: None,
@@ -4995,6 +5195,8 @@ impl Dialect {
                 this: subquery,
                 alias: Identifier::new(&alias_name),
                 column_aliases: col_aliases,
+                alias_explicit_as: false,
+                alias_keyword: None,
                 pre_alias_comments: vec![],
                 trailing_comments: vec![],
                 inferred_type: None,
@@ -5080,6 +5282,8 @@ impl Dialect {
                 Identifier::new(col_name),
                 Identifier::new("this"),
             ],
+            alias_explicit_as: false,
+            alias_keyword: None,
             pre_alias_comments: vec![],
             trailing_comments: vec![],
             inferred_type: None,
@@ -5122,6 +5326,8 @@ impl Dialect {
             this: dateadd_expr,
             alias: Identifier::new(col_name),
             column_aliases: vec![],
+            alias_explicit_as: false,
+            alias_keyword: None,
             pre_alias_comments: vec![],
             trailing_comments: vec![],
             inferred_type: None,
@@ -5139,6 +5345,8 @@ impl Dialect {
             this: Expression::Select(Box::new(inner_select)),
             alias: None,
             column_aliases: vec![],
+            alias_explicit_as: false,
+            alias_keyword: None,
             order_by: None,
             limit: None,
             offset: None,
@@ -5183,6 +5391,8 @@ impl Dialect {
             this: Expression::Select(Box::new(outer_select)),
             alias: None,
             column_aliases: vec![],
+            alias_explicit_as: false,
+            alias_keyword: None,
             order_by: None,
             limit: None,
             offset: None,
@@ -5776,6 +5986,8 @@ impl Dialect {
                                     this: Expression::Values(vals.clone()),
                                     alias: Some(Identifier::new("_values".to_string())),
                                     column_aliases: Vec::new(),
+                                    alias_explicit_as: false,
+                                    alias_keyword: None,
                                     order_by: None,
                                     limit: None,
                                     offset: None,
@@ -6398,6 +6610,8 @@ impl Dialect {
                                     this: Expression::Select(Box::new(inner_select)),
                                     alias: Some(a.alias.clone()),
                                     column_aliases: Vec::new(),
+                                    alias_explicit_as: false,
+                                    alias_keyword: None,
                                     order_by: None,
                                     limit: None,
                                     offset: None,
@@ -6505,6 +6719,8 @@ impl Dialect {
                                                                 this: unnest_expr,
                                                                 alias: Identifier::new("_t0"),
                                                                 column_aliases: vec![alias.clone()],
+                                                                alias_explicit_as: false,
+                                                                alias_keyword: None,
                                                                 pre_alias_comments: vec![],
                                                                 trailing_comments: vec![],
                                                                 inferred_type: None,
@@ -6517,6 +6733,8 @@ impl Dialect {
                                                                 this: unnest_expr,
                                                                 alias: alias.clone(),
                                                                 column_aliases: vec![],
+                                                                alias_explicit_as: false,
+                                                                alias_keyword: None,
                                                                 pre_alias_comments: vec![],
                                                                 trailing_comments: vec![],
                                                                 inferred_type: None,
@@ -9756,6 +9974,8 @@ impl Dialect {
                                     this: Expression::Select(Box::new(new_select)),
                                     alias: None,
                                     column_aliases: Vec::new(),
+                                    alias_explicit_as: false,
+                                    alias_keyword: None,
                                     order_by: None,
                                     limit: None,
                                     offset: None,
@@ -21143,6 +21363,8 @@ impl Dialect {
                                                 this: unnest_expr,
                                                 alias: u_id.clone(),
                                                 column_aliases: Vec::new(),
+                                                alias_explicit_as: false,
+                                                alias_keyword: None,
                                                 pre_alias_comments: Vec::new(),
                                                 trailing_comments: Vec::new(),
                                                 inferred_type: None,
@@ -28077,6 +28299,8 @@ impl Dialect {
                                             )),
                                             alias: Identifier::new("_t0"),
                                             column_aliases: vec![Identifier::new(&param_name)],
+                                            alias_explicit_as: false,
+                                            alias_keyword: None,
                                             pre_alias_comments: Vec::new(),
                                             trailing_comments: Vec::new(),
                                             inferred_type: None,
@@ -30368,6 +30592,8 @@ impl Dialect {
                                         this: unnest_expr,
                                         alias: u_id.clone(),
                                         column_aliases: Vec::new(),
+                                        alias_explicit_as: false,
+                                        alias_keyword: None,
                                         pre_alias_comments: Vec::new(),
                                         trailing_comments: Vec::new(),
                                         inferred_type: None,
@@ -31026,6 +31252,8 @@ impl Dialect {
                 this: series_unnest_expr,
                 alias: Identifier::new(series_source_alias.clone()),
                 column_aliases: col_aliases,
+                alias_explicit_as: false,
+                alias_keyword: None,
                 pre_alias_comments: Vec::new(),
                 trailing_comments: Vec::new(),
                 inferred_type: None,
@@ -31069,6 +31297,8 @@ impl Dialect {
                             Identifier::new(actual_col_name.clone()),
                             Identifier::new(info.pos_alias.clone()),
                         ],
+                        alias_explicit_as: false,
+                        alias_keyword: None,
                         pre_alias_comments: Vec::new(),
                         trailing_comments: Vec::new(),
                         inferred_type: None,
@@ -31100,6 +31330,8 @@ impl Dialect {
                             Identifier::new(actual_col_name.clone()),
                             Identifier::new("this".to_string()),
                         ],
+                        alias_explicit_as: false,
+                        alias_keyword: None,
                         pre_alias_comments: Vec::new(),
                         trailing_comments: Vec::new(),
                         inferred_type: None,
@@ -32016,7 +32248,7 @@ impl Dialect {
             match unit.trim().to_ascii_uppercase().as_str() {
                 "YEAR" | "YEARS" => Some(IntervalUnit::Year),
                 "QUARTER" | "QUARTERS" => Some(IntervalUnit::Quarter),
-                "MONTH" | "MONTHS" => Some(IntervalUnit::Month),
+                "MONTH" | "MONTHS" | "MON" | "MONS" | "MM" => Some(IntervalUnit::Month),
                 "WEEK" | "WEEKS" | "ISOWEEK" => Some(IntervalUnit::Week),
                 "DAY" | "DAYS" => Some(IntervalUnit::Day),
                 "HOUR" | "HOURS" => Some(IntervalUnit::Hour),
@@ -36688,7 +36920,9 @@ impl Dialect {
         match s {
             "YEAR" | "YY" | "YYYY" => crate::expressions::IntervalUnit::Year,
             "QUARTER" | "QQ" | "Q" => crate::expressions::IntervalUnit::Quarter,
-            "MONTH" | "MM" | "M" => crate::expressions::IntervalUnit::Month,
+            "MONTH" | "MONTHS" | "MON" | "MONS" | "MM" | "M" => {
+                crate::expressions::IntervalUnit::Month
+            }
             "WEEK" | "WK" | "WW" | "ISOWEEK" => crate::expressions::IntervalUnit::Week,
             "DAY" | "DD" | "D" | "DY" => crate::expressions::IntervalUnit::Day,
             "HOUR" | "HH" => crate::expressions::IntervalUnit::Hour,

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/dialects/snowflake.rs

@@ -117,6 +117,8 @@ impl DialectImpl for SnowflakeDialect {
                     this: inner,
                     alias: None,
                     column_aliases: Vec::new(),
+                    alias_explicit_as: false,
+                    alias_keyword: None,
                     order_by: None,
                     limit: None,
                     offset: None,
@@ -394,6 +396,8 @@ impl DialectImpl for SnowflakeDialect {
                         crate::expressions::Identifier::new("value"),
                         crate::expressions::Identifier::new("this"),
                     ],
+                    alias_explicit_as: false,
+                    alias_keyword: None,
                     pre_alias_comments: vec![],
                     trailing_comments: vec![],
                     inferred_type: None,

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/dialects/spark.rs

@@ -628,6 +628,8 @@ impl SparkDialect {
                                     this: arg,
                                     alias: crate::expressions::Identifier::new(&name),
                                     column_aliases: Vec::new(),
+                                    alias_explicit_as: false,
+                                    alias_keyword: None,
                                     pre_alias_comments: Vec::new(),
                                     trailing_comments: Vec::new(),
                                     inferred_type: None,
@@ -640,6 +642,8 @@ impl SparkDialect {
                                     this: arg,
                                     alias: crate::expressions::Identifier::new(&name),
                                     column_aliases: Vec::new(),
+                                    alias_explicit_as: false,
+                                    alias_keyword: None,
                                     pre_alias_comments: Vec::new(),
                                     trailing_comments: Vec::new(),
                                     inferred_type: None,
@@ -673,6 +677,8 @@ impl SparkDialect {
                                     this: pair[1].clone(),
                                     alias: crate::expressions::Identifier::new(field_name),
                                     column_aliases: Vec::new(),
+                                    alias_explicit_as: false,
+                                    alias_keyword: None,
                                     pre_alias_comments: Vec::new(),
                                     trailing_comments: Vec::new(),
                                     inferred_type: None,
@@ -855,6 +861,8 @@ impl SparkDialect {
                                     this: pair[1].clone(),
                                     alias: crate::expressions::Identifier::new(key.clone()),
                                     column_aliases: vec![],
+                                    alias_explicit_as: false,
+                                    alias_keyword: None,
                                     pre_alias_comments: vec![],
                                     trailing_comments: vec![],
                                     inferred_type: None,

{polyglot_sql-0.3.6 → polyglot_sql-0.3.9}/crates/polyglot-sql/src/dialects/tsql.rs

@@ -126,6 +126,8 @@ impl DialectImpl for TSQLDialect {
                                             this: op.right,
                                             alias: col.name.clone(),
                                             column_aliases: Vec::new(),
+                                            alias_explicit_as: false,
+                                            alias_keyword: None,
                                             pre_alias_comments: Vec::new(),
                                             trailing_comments: Vec::new(),
                                             inferred_type: None,
@@ -138,6 +140,8 @@ impl DialectImpl for TSQLDialect {
                                             this: op.right,
                                             alias: ident.clone(),
                                             column_aliases: Vec::new(),
+                                            alias_explicit_as: false,
+                                            alias_keyword: None,
                                             pre_alias_comments: Vec::new(),
                                             trailing_comments: Vec::new(),
                                             inferred_type: None,
@@ -1217,6 +1221,8 @@ impl TSQLDialect {
                             span: None,
                         },
                         column_aliases: Vec::new(),
+                        alias_explicit_as: false,
+                        alias_keyword: None,
                         pre_alias_comments: Vec::new(),
                         trailing_comments: Vec::new(),
                         inferred_type: None,