polyglot-sql 0.5.0__tar.gz → 0.5.2__tar.gz

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/Cargo.lock

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

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/Cargo.toml

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

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.5.0
+Version: 0.5.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -55,6 +55,15 @@ ast = polyglot_sql.parse_one("SELECT 1 + 2", dialect="postgres")
 polyglot_sql.generate(ast, dialect="mysql")
 ```
 
+```python
+data_type = polyglot_sql.parse_data_type("DECIMAL(10, 2)", dialect="duckdb")
+data_type.sql("postgres")
+# "DECIMAL(10, 2)"
+
+# SQLGlot-compatible narrow form for data types only:
+polyglot_sql.parse_one("VARCHAR(255)", dialect="duckdb", into=polyglot_sql.DataType)
+```
+
 ```python
 polyglot_sql.format_sql("SELECT a,b FROM t WHERE x=1", dialect="postgres")
 ```
@@ -114,6 +123,32 @@ print(payload["facet"]["fields"])
 OpenLineage helpers only produce compatible payloads. Transport and client
 emission are intentionally out of scope.
 
+```python
+analysis = polyglot_sql.analyze_query(
+    "SELECT SUM(o.amount) AS total FROM orders AS o",
+    {
+        "dialect": "generic",
+        "schema": {
+            "tables": [
+                {
+                    "name": "orders",
+                    "columns": [{"name": "amount", "type": "DECIMAL(10,2)"}],
+                }
+            ]
+        },
+    },
+)
+print(analysis["projections"][0]["transformKind"])  # "aggregation"
+print(analysis["projections"][0]["typeHint"])       # "DECIMAL(10, 2)"
+print(analysis["baseTables"][0]["name"])            # "orders"
+```
+
+`analysis["relations"]` reports sources visible in the analyzed scope.
+`analysis["baseTables"]` reports deduplicated physical table dependencies across
+nested CTEs, derived tables, subqueries, and set-operation branches. Validation
+uses broad type families, while query analysis preserves parseable detailed
+schema type strings for projection `typeHint` values.
+
 ## API Reference
 
 All functions are exported from `polyglot_sql`.
@@ -121,6 +156,8 @@ All functions are exported from `polyglot_sql`.
 - `transpile(sql: str, read: str = "generic", write: str = "generic", *, pretty: bool = False) -> list[str]`
 - `parse(sql: str, dialect: str = "generic") -> list[dict]`
 - `parse_one(sql: str, dialect: str = "generic") -> dict`
+- `parse_one(sql: str, dialect: str = "generic", *, into=polyglot_sql.DataType) -> DataType` (only `DataType` is supported for `into`)
+- `parse_data_type(sql: str, dialect: str = "generic") -> DataType`
 - `generate(ast: dict | list[dict], dialect: str = "generic", *, pretty: bool = False) -> list[str]`
 - `format_sql(sql: str, dialect: str = "generic", *, max_input_bytes: int | None = None, max_tokens: int | None = None, max_ast_nodes: int | None = None, max_set_op_chain: int | None = None) -> str`
 - `format(sql: str, dialect: str = "generic", *, max_input_bytes: int | None = None, max_tokens: int | None = None, max_ast_nodes: int | None = None, max_set_op_chain: int | None = None) -> str` (alias of `format_sql`)
@@ -128,6 +165,7 @@ All functions are exported from `polyglot_sql`.
 - `optimize(sql: str, dialect: str = "generic") -> str`
 - `lineage(column: str, sql: str, dialect: str = "generic") -> dict`
 - `source_tables(column: str, sql: str, dialect: str = "generic") -> list[str]`
+- `analyze_query(sql: str, options: dict | None = None, dialect: str = "generic") -> dict`
 - `openlineage_column_lineage(sql: str, options: dict) -> dict`
 - `openlineage_job_event(sql: str, options: dict) -> dict`
 - `openlineage_run_event(sql: str, options: dict) -> dict`

{polyglot_sql-0.5.0/crates/polyglot-sql-python → polyglot_sql-0.5.2}/README.md

@@ -28,6 +28,15 @@ ast = polyglot_sql.parse_one("SELECT 1 + 2", dialect="postgres")
 polyglot_sql.generate(ast, dialect="mysql")
 ```
 
+```python
+data_type = polyglot_sql.parse_data_type("DECIMAL(10, 2)", dialect="duckdb")
+data_type.sql("postgres")
+# "DECIMAL(10, 2)"
+
+# SQLGlot-compatible narrow form for data types only:
+polyglot_sql.parse_one("VARCHAR(255)", dialect="duckdb", into=polyglot_sql.DataType)
+```
+
 ```python
 polyglot_sql.format_sql("SELECT a,b FROM t WHERE x=1", dialect="postgres")
 ```
@@ -87,6 +96,32 @@ print(payload["facet"]["fields"])
 OpenLineage helpers only produce compatible payloads. Transport and client
 emission are intentionally out of scope.
 
+```python
+analysis = polyglot_sql.analyze_query(
+    "SELECT SUM(o.amount) AS total FROM orders AS o",
+    {
+        "dialect": "generic",
+        "schema": {
+            "tables": [
+                {
+                    "name": "orders",
+                    "columns": [{"name": "amount", "type": "DECIMAL(10,2)"}],
+                }
+            ]
+        },
+    },
+)
+print(analysis["projections"][0]["transformKind"])  # "aggregation"
+print(analysis["projections"][0]["typeHint"])       # "DECIMAL(10, 2)"
+print(analysis["baseTables"][0]["name"])            # "orders"
+```
+
+`analysis["relations"]` reports sources visible in the analyzed scope.
+`analysis["baseTables"]` reports deduplicated physical table dependencies across
+nested CTEs, derived tables, subqueries, and set-operation branches. Validation
+uses broad type families, while query analysis preserves parseable detailed
+schema type strings for projection `typeHint` values.
+
 ## API Reference
 
 All functions are exported from `polyglot_sql`.
@@ -94,6 +129,8 @@ All functions are exported from `polyglot_sql`.
 - `transpile(sql: str, read: str = "generic", write: str = "generic", *, pretty: bool = False) -> list[str]`
 - `parse(sql: str, dialect: str = "generic") -> list[dict]`
 - `parse_one(sql: str, dialect: str = "generic") -> dict`
+- `parse_one(sql: str, dialect: str = "generic", *, into=polyglot_sql.DataType) -> DataType` (only `DataType` is supported for `into`)
+- `parse_data_type(sql: str, dialect: str = "generic") -> DataType`
 - `generate(ast: dict | list[dict], dialect: str = "generic", *, pretty: bool = False) -> list[str]`
 - `format_sql(sql: str, dialect: str = "generic", *, max_input_bytes: int | None = None, max_tokens: int | None = None, max_ast_nodes: int | None = None, max_set_op_chain: int | None = None) -> str`
 - `format(sql: str, dialect: str = "generic", *, max_input_bytes: int | None = None, max_tokens: int | None = None, max_ast_nodes: int | None = None, max_set_op_chain: int | None = None) -> str` (alias of `format_sql`)
@@ -101,6 +138,7 @@ All functions are exported from `polyglot_sql`.
 - `optimize(sql: str, dialect: str = "generic") -> str`
 - `lineage(column: str, sql: str, dialect: str = "generic") -> dict`
 - `source_tables(column: str, sql: str, dialect: str = "generic") -> list[str]`
+- `analyze_query(sql: str, options: dict | None = None, dialect: str = "generic") -> dict`
 - `openlineage_column_lineage(sql: str, options: dict) -> dict`
 - `openlineage_job_event(sql: str, options: dict) -> dict`
 - `openlineage_run_event(sql: str, options: dict) -> dict`

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/crates/polyglot-sql/Cargo.toml

@@ -106,7 +106,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.5.0", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.5.2", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/crates/polyglot-sql/README.md

@@ -7,6 +7,7 @@ Part of the [Polyglot](https://github.com/tobilg/polyglot) project.
 ## Features
 
 - **Parse** SQL into a fully-typed AST with 200+ expression types
+- **Parse standalone data types** such as `DECIMAL(10, 2)` without a statement wrapper
 - **Generate** SQL from AST nodes for any target dialect
 - **Transpile** between any pair of 32 dialects in one call
 - **Format** / pretty-print SQL
@@ -14,6 +15,7 @@ Part of the [Polyglot](https://github.com/tobilg/polyglot) project.
 - **AST traversal** utilities (DFS/BFS iterators, transform, walk)
 - **Validation** with syntax checking and error location reporting
 - **Schema** module for column resolution and type annotation
+- **Compact query analysis** for projection, relation, CTE, set-operation, and upstream-reference facts
 
 ## Usage
 
@@ -23,12 +25,12 @@ By default, `polyglot-sql` enables the full public API. Parser-only consumers ca
 disable default features and opt into only the dialect parsers they need:
 
 ```toml
-polyglot-sql = { version = "0.4", default-features = false }
+polyglot-sql = { version = "0.5", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.4",
+    version = "0.5",
     default-features = false,
     features = ["dialect-clickhouse"],
 }
@@ -42,14 +44,14 @@ Examples:
 ```toml
 # Parse and generate SQL for one dialect.
 polyglot-sql = {
-    version = "0.4",
+    version = "0.5",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.4",
+    version = "0.5",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }
@@ -103,6 +105,19 @@ let sql = generate(&ast[0], DialectType::Postgres).unwrap();
 assert_eq!(sql, "SELECT 1 + 2");
 ```
 
+### Standalone Data Types
+
+```rust
+use polyglot_sql::{generate_data_type, parse_data_type, DialectType};
+
+let data_type = parse_data_type("DECIMAL(10, 2)", DialectType::DuckDB).unwrap();
+let sql = generate_data_type(&data_type, DialectType::Postgres).unwrap();
+assert_eq!(sql, "DECIMAL(10, 2)");
+```
+
+`parse_data_type` parses exactly one type string and rejects trailing SQL. Type
+rendering requires the `generate` feature, which is enabled by default.
+
 ### Format With Guard Options
 
 Formatting is protected by guard limits by default:
@@ -295,6 +310,40 @@ Schema-aware validation emits stable codes such as:
 - `E210-E217` and `W210-W216` for type checks
 - `E220`, `E221`, `W220`, `W221`, `W222` for reference/FK checks
 
+### Compact Query Analysis
+
+Use `analyze_query` when you need high-level facts without consuming the full AST
+or full lineage graph. `relations` reports sources visible in the analyzed
+scope, while `base_tables` reports deduplicated physical table dependencies
+across CTEs, derived tables, subqueries, and set-operation branches. When a
+`ValidationSchema` is supplied, detailed type strings such as `DECIMAL(10,2)`
+are preserved in projection `type_hint` values when parseable.
+
+```rust
+use polyglot_sql::{analyze_query, AnalyzeQueryOptions, DialectType, QueryShape};
+
+let schema: polyglot_sql::ValidationSchema = serde_json::from_value(serde_json::json!({
+    "tables": [{
+        "name": "orders",
+        "columns": [{"name": "amount", "type": "DECIMAL(10,2)"}]
+    }]
+})).unwrap();
+
+let analysis = analyze_query(
+    "SELECT SUM(o.amount) AS total FROM orders o",
+    AnalyzeQueryOptions {
+        dialect: DialectType::Generic,
+        schema: Some(schema),
+    },
+).unwrap();
+
+assert_eq!(analysis.shape, QueryShape::Select);
+assert_eq!(analysis.projections[0].name.as_deref(), Some("total"));
+assert_eq!(analysis.projections[0].transform_kind, polyglot_sql::TransformKind::Aggregation);
+assert_eq!(analysis.base_tables[0].name, "orders");
+assert_eq!(analysis.base_tables[0].alias.as_deref(), Some("o"));
+```
+
 ### Tokenize
 
 Access the raw token stream with full source position spans. Each token carries a `Span` with byte offsets and line/column numbers.

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/dialects/mod.rs

@@ -158,9 +158,9 @@ pub use trino::TrinoDialect;
 pub use tsql::TSQLDialect;
 
 use crate::error::Result;
-use crate::expressions::Expression;
 #[cfg(feature = "transpile")]
 use crate::expressions::{ColumnConstraint, Function, Identifier, Literal};
+use crate::expressions::{DataType, Expression};
 #[cfg(any(
     feature = "transpile",
     feature = "ast-tools",
@@ -3936,6 +3936,20 @@ impl Dialect {
         parser.parse()
     }
 
+    /// Parse a standalone SQL data type using this dialect's tokenizer and parser.
+    ///
+    /// This accepts type strings such as `DECIMAL(10, 2)`, `INT[]`, or
+    /// `STRUCT(a INT, b VARCHAR)` without requiring a surrounding statement.
+    pub fn parse_data_type(&self, sql: &str) -> Result<DataType> {
+        let tokens = self.tokenizer.tokenize(sql)?;
+        let config = crate::parser::ParserConfig {
+            dialect: Some(self.dialect_type),
+            ..Default::default()
+        };
+        let mut parser = Parser::with_source(tokens, config, sql.to_string());
+        parser.parse_standalone_data_type()
+    }
+
     /// Tokenize SQL using this dialect's tokenizer configuration.
     pub fn tokenize(&self, sql: &str) -> Result<Vec<Token>> {
         self.tokenizer.tokenize(sql)

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/dialects/postgres.rs

@@ -65,6 +65,19 @@ impl DialectImpl for PostgresDialect {
         config
             .keywords
             .insert("EXEC".to_string(), TokenType::Command);
+        for command in [
+            "BASE_BACKUP",
+            "CREATE_REPLICATION_SLOT",
+            "DROP_REPLICATION_SLOT",
+            "IDENTIFY_SYSTEM",
+            "READ_REPLICATION_SLOT",
+            "START_REPLICATION",
+            "TIMELINE_HISTORY",
+        ] {
+            config
+                .keywords
+                .insert(command.to_string(), TokenType::Command);
+        }
         config
     }
 

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/generator.rs

@@ -19705,9 +19705,15 @@ impl Generator {
             self.write_simple_interval_unit(unit, false); // Use singular form for DATEDIFF
             self.write(", ");
         }
-        self.generate_expression(&f.this)?;
-        self.write(", ");
-        self.generate_expression(&f.expression)?;
+        if self.config.dialect == Some(DialectType::Snowflake) {
+            self.generate_expression(&f.expression)?;
+            self.write(", ");
+            self.generate_expression(&f.this)?;
+        } else {
+            self.generate_expression(&f.this)?;
+            self.write(", ");
+            self.generate_expression(&f.expression)?;
+        }
         self.write(")");
         Ok(())
     }

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/lib.rs

@@ -37,6 +37,8 @@ pub mod optimizer;
 pub mod parser;
 #[cfg(feature = "planner")]
 pub mod planner;
+#[cfg(all(feature = "semantic", feature = "generate"))]
+pub mod query_analysis;
 #[cfg(feature = "semantic")]
 pub mod resolver;
 #[cfg(feature = "semantic")]
@@ -72,7 +74,7 @@ pub use dialects::{TranspileOptions, TranspileTarget};
 pub use error::{Error, Result};
 #[cfg(feature = "semantic")]
 pub use error::{ValidationError, ValidationResult, ValidationSeverity};
-pub use expressions::Expression;
+pub use expressions::{DataType, Expression};
 #[cfg(feature = "semantic")]
 pub use function_catalog::{
     FunctionCatalog, FunctionNameCase, FunctionSignature, HashMapFunctionCatalog,
@@ -89,6 +91,12 @@ pub use optimizer::{
     annotate_types, qualify_tables, QualifyTablesOptions, TypeAnnotator, TypeCoercionClass,
 };
 pub use parser::Parser;
+#[cfg(all(feature = "semantic", feature = "generate"))]
+pub use query_analysis::{
+    analyze_query, AnalyzeQueryOptions, ColumnReferenceFact, ProjectionFact, QueryAnalysis,
+    QueryShape, ReferenceConfidence, RelationFact, SetOperationBranchFact, SetOperationFact,
+    TransformKind,
+};
 #[cfg(feature = "semantic")]
 pub use resolver::{is_column_ambiguous, resolve_column, Resolver, ResolverError, ResolverResult};
 #[cfg(feature = "semantic")]
@@ -495,6 +503,31 @@ pub fn parse_one(sql: &str, dialect: DialectType) -> Result<Expression> {
     Ok(expressions.remove(0))
 }
 
+/// Parse a standalone SQL data type.
+///
+/// # Arguments
+/// * `sql` - The data type string to parse, e.g. `DECIMAL(10, 2)`
+/// * `dialect` - The dialect to use for parsing
+///
+/// # Returns
+/// The parsed data type
+pub fn parse_data_type(sql: &str, dialect: DialectType) -> Result<DataType> {
+    Dialect::get(dialect).parse_data_type(sql)
+}
+
+/// Generate SQL from a standalone data type.
+///
+/// # Arguments
+/// * `data_type` - The data type to render
+/// * `dialect` - The target dialect
+///
+/// # Returns
+/// The generated type SQL string
+#[cfg(feature = "generate")]
+pub fn generate_data_type(data_type: &DataType, dialect: DialectType) -> Result<String> {
+    Dialect::get(dialect).generate(&Expression::DataType(data_type.clone()))
+}
+
 /// Generate SQL from an AST.
 ///
 /// # Arguments

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/lineage.rs

@@ -235,6 +235,25 @@ fn lineage_from_expression(
     )
 }
 
+pub(crate) fn lineage_by_index_from_expression(
+    column_index: usize,
+    sql: &Expression,
+    dialect: Option<DialectType>,
+    trim_selects: bool,
+) -> Result<LineageNode> {
+    let sql = lineage_effective_expression(sql);
+    let scope = build_scope(sql);
+    to_node(
+        ColumnRef::Index(column_index),
+        &scope,
+        dialect,
+        "",
+        "",
+        "",
+        trim_selects,
+    )
+}
+
 fn lineage_effective_expression(sql: &Expression) -> &Expression {
     match sql {
         Expression::Prepare(prepare) => &prepare.statement,
@@ -753,12 +772,32 @@ fn to_node_inner(
     apply_scope_context(&mut node, scope, source_name, reference_node_name);
 
     // 5. Star handling — add downstream for each source
-    if matches!(&select_expr, Expression::Star(_)) {
+    if let Expression::Star(star) = &select_expr {
+        let star_table = star
+            .table
+            .as_ref()
+            .map(|identifier| identifier.name.as_str());
         for (name, source_info) in &scope.sources {
+            if let Some(star_table) = star_table {
+                let table_matches = name.eq_ignore_ascii_case(star_table)
+                    || source_info
+                        .alias
+                        .as_deref()
+                        .is_some_and(|alias| alias.eq_ignore_ascii_case(star_table))
+                    || matches!(
+                        &source_info.expression,
+                        Expression::Table(table_ref)
+                            if table_name_from_table_ref(table_ref).eq_ignore_ascii_case(star_table)
+                    );
+                if !table_matches {
+                    continue;
+                }
+            }
+
             let mut child = LineageNode::new(
                 format!("{}.*", name),
                 Expression::Star(crate::expressions::Star {
-                    table: None,
+                    table: star.table.clone(),
                     except: None,
                     replace: None,
                     rename: None,

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/optimizer/qualify_columns.rs

@@ -653,21 +653,23 @@ fn expand_stars(
 
     for expr in &select.expressions {
         match expr {
-            Expression::Star(_) => {
+            Expression::Star(star) => {
                 has_star = true;
-                for source_name in &ordered_sources {
-                    if let Ok(columns) = resolver.get_source_columns(source_name) {
+                if let Some(table) = &star.table {
+                    let table_name = &table.name;
+                    if !ordered_sources.contains(table_name) {
+                        return Err(QualifyColumnsError::UnknownTable(table_name.clone()));
+                    }
+                    if let Ok(columns) = resolver.get_source_columns(table_name) {
                         if columns.contains(&"*".to_string()) || columns.is_empty() {
                             return Ok(());
                         }
                         for col_name in &columns {
                             if coalesced_columns.contains(col_name) {
-                                // Already emitted as COALESCE, skip
                                 continue;
                             }
                             if let Some(tables) = column_tables.get(col_name) {
-                                if tables.contains(source_name) {
-                                    // Emit COALESCE and mark as coalesced
+                                if tables.contains(table_name) {
                                     coalesced_columns.insert(col_name.clone());
                                     let coalesce = make_coalesce(col_name, tables);
                                     new_selections.push(Expression::Alias(Box::new(Alias {
@@ -684,7 +686,41 @@ fn expand_stars(
                                 }
                             }
                             new_selections
-                                .push(create_qualified_column(col_name, Some(source_name)));
+                                .push(create_qualified_column(col_name, Some(table_name)));
+                        }
+                    }
+                } else {
+                    for source_name in &ordered_sources {
+                        if let Ok(columns) = resolver.get_source_columns(source_name) {
+                            if columns.contains(&"*".to_string()) || columns.is_empty() {
+                                return Ok(());
+                            }
+                            for col_name in &columns {
+                                if coalesced_columns.contains(col_name) {
+                                    // Already emitted as COALESCE, skip
+                                    continue;
+                                }
+                                if let Some(tables) = column_tables.get(col_name) {
+                                    if tables.contains(source_name) {
+                                        // Emit COALESCE and mark as coalesced
+                                        coalesced_columns.insert(col_name.clone());
+                                        let coalesce = make_coalesce(col_name, tables);
+                                        new_selections.push(Expression::Alias(Box::new(Alias {
+                                            this: coalesce,
+                                            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,
+                                        })));
+                                        continue;
+                                    }
+                                }
+                                new_selections
+                                    .push(create_qualified_column(col_name, Some(source_name)));
+                            }
                         }
                     }
                 }

{polyglot_sql-0.5.0 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/parser.rs

@@ -740,6 +740,28 @@ impl Parser {
         Ok(statements)
     }
 
+    /// Parse exactly one standalone data type from the token stream.
+    ///
+    /// This entry point is intended for callers that need to parse native type
+    /// strings such as `DECIMAL(10, 2)` without wrapping them in a SQL statement
+    /// or `CAST(...)` expression.
+    pub fn parse_standalone_data_type(&mut self) -> Result<DataType> {
+        let data_type = self.parse_data_type()?;
+
+        if self.check(TokenType::Semicolon) {
+            self.skip();
+        }
+
+        if !self.is_at_end() {
+            return Err(self.parse_error(format!(
+                "Unexpected token after data type: {}",
+                self.peek().text
+            )));
+        }
+
+        Ok(data_type)
+    }
+
     /// Parse a single SQL statement from the current position in the token stream.
     ///
     /// Dispatches to the appropriate sub-parser based on the leading keyword
@@ -24338,10 +24360,23 @@ impl Parser {
 
     /// Parse SET statement
     fn parse_set(&mut self) -> Result<Expression> {
+        let statement_start = self.current;
         self.expect(TokenType::Set)?;
 
         let mut items = Vec::new();
 
+        // T-SQL: SET STATISTICS TIME|IO|XML|PROFILE ON|OFF. The existing SET
+        // parser handles simple options like SET NOCOUNT ON, but these
+        // multi-token STATISTICS options are better preserved as commands.
+        if matches!(
+            self.config.dialect,
+            Some(crate::dialects::DialectType::TSQL)
+        ) && self.check_identifier("STATISTICS")
+        {
+            self.current = statement_start;
+            return self.fallback_to_command(statement_start);
+        }
+
         // ClickHouse: SET DEFAULT ROLE ... TO user - parse as command
         if matches!(
             self.config.dialect,