polyglot-sql 0.4.4__tar.gz → 0.5.1__tar.gz

{polyglot_sql-0.4.4 → polyglot_sql-0.5.1}/Cargo.lock

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

{polyglot_sql-0.4.4 → polyglot_sql-0.5.1}/Cargo.toml

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

{polyglot_sql-0.4.4 → polyglot_sql-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.4.4
+Version: 0.5.1
 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,24 @@ 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 CAST(total AS TEXT) AS total_text FROM orders",
+    {
+        "dialect": "generic",
+        "schema": {
+            "tables": [
+                {
+                    "name": "orders",
+                    "columns": [{"name": "total", "type": "INT"}],
+                }
+            ]
+        },
+    },
+)
+print(analysis["projections"][0]["transformKind"])  # "cast"
+```
+
 ## API Reference
 
 All functions are exported from `polyglot_sql`.
@@ -121,6 +148,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 +157,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.4.4/crates/polyglot-sql-python → polyglot_sql-0.5.1}/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,24 @@ 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 CAST(total AS TEXT) AS total_text FROM orders",
+    {
+        "dialect": "generic",
+        "schema": {
+            "tables": [
+                {
+                    "name": "orders",
+                    "columns": [{"name": "total", "type": "INT"}],
+                }
+            ]
+        },
+    },
+)
+print(analysis["projections"][0]["transformKind"])  # "cast"
+```
+
 ## API Reference
 
 All functions are exported from `polyglot_sql`.
@@ -94,6 +121,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 +130,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.4.4 → polyglot_sql-0.5.1}/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.4.4", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.5.1", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.4.4 → polyglot_sql-0.5.1}/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,26 @@ 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:
+
+```rust
+use polyglot_sql::{analyze_query, AnalyzeQueryOptions, DialectType, QueryShape};
+
+let analysis = analyze_query(
+    "SELECT o.total AS total FROM orders o",
+    AnalyzeQueryOptions {
+        dialect: DialectType::Generic,
+        schema: None,
+    },
+).unwrap();
+
+assert_eq!(analysis.shape, QueryShape::Select);
+assert_eq!(analysis.projections[0].name.as_deref(), Some("total"));
+```
+
 ### 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.4.4 → polyglot_sql-0.5.1}/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",
@@ -168,12 +168,16 @@ use crate::expressions::{ColumnConstraint, Function, Identifier, Literal};
     feature = "semantic"
 ))]
 use crate::expressions::{From, FunctionBody, Join, Null, OrderBy, OutputClause, TableRef, With};
+#[cfg(feature = "transpile")]
+use crate::generator::UnsupportedLevel;
 #[cfg(feature = "generate")]
 use crate::generator::{Generator, GeneratorConfig};
 use crate::parser::Parser;
 #[cfg(feature = "transpile")]
 use crate::tokens::TokenType;
 use crate::tokens::{Token, Tokenizer, TokenizerConfig};
+#[cfg(feature = "transpile")]
+use crate::traversal::ExpressionWalk;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::{Arc, LazyLock, RwLock};
@@ -3730,19 +3734,60 @@ pub struct Dialect {
 /// The struct derives `Serialize`/`Deserialize` using camelCase field names so
 /// it can be round-tripped over JSON bridges (C FFI, WASM) without mapping.
 #[cfg(feature = "transpile")]
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", default)]
 #[non_exhaustive]
 pub struct TranspileOptions {
     /// Whether to pretty-print the output SQL.
     pub pretty: bool,
+    /// How unsupported target-dialect constructs should be handled.
+    ///
+    /// The default is [`UnsupportedLevel::Warn`], which preserves the current
+    /// compatibility behavior and continues transpilation.
+    pub unsupported_level: UnsupportedLevel,
+    /// Maximum number of unsupported diagnostics to include in raised errors.
+    pub max_unsupported: usize,
+}
+
+#[cfg(feature = "transpile")]
+impl Default for TranspileOptions {
+    fn default() -> Self {
+        Self {
+            pretty: false,
+            unsupported_level: UnsupportedLevel::Warn,
+            max_unsupported: 3,
+        }
+    }
 }
 
 #[cfg(feature = "transpile")]
 impl TranspileOptions {
     /// Construct options with pretty-printing enabled.
     pub fn pretty() -> Self {
-        Self { pretty: true }
+        Self {
+            pretty: true,
+            ..Default::default()
+        }
+    }
+
+    /// Construct options that raise when known unsupported constructs remain.
+    pub fn strict() -> Self {
+        Self {
+            unsupported_level: UnsupportedLevel::Raise,
+            ..Default::default()
+        }
+    }
+
+    /// Set how unsupported target-dialect constructs should be handled.
+    pub fn with_unsupported_level(mut self, level: UnsupportedLevel) -> Self {
+        self.unsupported_level = level;
+        self
+    }
+
+    /// Set the maximum number of unsupported diagnostics to include in raised errors.
+    pub fn with_max_unsupported(mut self, max: usize) -> Self {
+        self.max_unsupported = max;
+        self
     }
 }
 
@@ -3891,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)
@@ -3956,6 +4015,23 @@ impl Dialect {
         generator.generate(expr)
     }
 
+    /// Generate SQL from an expression with source dialect and transpile options.
+    #[cfg(all(feature = "generate", feature = "transpile"))]
+    fn generate_with_transpile_options(
+        &self,
+        expr: &Expression,
+        source: DialectType,
+        opts: &TranspileOptions,
+    ) -> Result<String> {
+        let mut config = self.get_config_for_expr(expr);
+        config.source_dialect = Some(source);
+        config.pretty = opts.pretty;
+        config.unsupported_level = opts.unsupported_level;
+        config.max_unsupported = opts.max_unsupported.max(1);
+        let mut generator = Generator::with_config(config);
+        generator.generate(expr)
+    }
+
     /// Generate SQL from an expression with forced identifier quoting (identify=True)
     #[cfg(feature = "generate")]
     pub fn generate_with_identify(&self, expr: &Expression) -> Result<String> {
@@ -4232,7 +4308,7 @@ impl Dialect {
         target: T,
         opts: TranspileOptions,
     ) -> Result<Vec<String>> {
-        target.with_dialect(|td| self.transpile_inner(sql, td, opts.pretty))
+        target.with_dialect(|td| self.transpile_inner(sql, td, &opts))
     }
 
     #[cfg(feature = "transpile")]
@@ -4240,7 +4316,7 @@ impl Dialect {
         &self,
         sql: &str,
         target_dialect: &Dialect,
-        pretty: bool,
+        opts: &TranspileOptions,
     ) -> Result<Vec<String>> {
         let target = target_dialect.dialect_type;
         if matches!(self.dialect_type, DialectType::PostgreSQL)
@@ -4256,11 +4332,8 @@ impl Dialect {
             return expressions
                 .into_iter()
                 .map(|expr| {
-                    if pretty {
-                        target_dialect.generate_pretty_with_source(&expr, self.dialect_type)
-                    } else {
-                        target_dialect.generate_with_source(&expr, self.dialect_type)
-                    }
+                    Self::reject_strict_unsupported(&expr, self.dialect_type, target, opts)?;
+                    target_dialect.generate_with_transpile_options(&expr, self.dialect_type, opts)
                 })
                 .collect();
         }
@@ -4744,14 +4817,16 @@ impl Dialect {
                     transformed
                 };
 
-                let mut sql = if pretty {
-                    target_dialect.generate_pretty_with_source(&transformed, self.dialect_type)?
-                } else {
-                    target_dialect.generate_with_source(&transformed, self.dialect_type)?
-                };
+                Self::reject_strict_unsupported(&transformed, self.dialect_type, target, opts)?;
+
+                let mut sql = target_dialect.generate_with_transpile_options(
+                    &transformed,
+                    self.dialect_type,
+                    opts,
+                )?;
 
                 // Align a known Snowflake pretty-print edge case with Python sqlglot output.
-                if pretty && target == DialectType::Snowflake {
+                if opts.pretty && target == DialectType::Snowflake {
                     sql = Self::normalize_snowflake_pretty(sql);
                 }
 
@@ -4764,6 +4839,193 @@ impl Dialect {
 // Transpile-only methods: cross-dialect normalization and helpers
 #[cfg(feature = "transpile")]
 impl Dialect {
+    fn reject_strict_unsupported(
+        expr: &Expression,
+        source: DialectType,
+        target: DialectType,
+        opts: &TranspileOptions,
+    ) -> Result<()> {
+        if !matches!(
+            opts.unsupported_level,
+            UnsupportedLevel::Raise | UnsupportedLevel::Immediate
+        ) {
+            return Ok(());
+        }
+
+        let mut diagnostics = Vec::new();
+
+        for node in expr.dfs() {
+            if matches!(target, DialectType::Fabric | DialectType::Hive)
+                && Self::node_has_recursive_with(node)
+            {
+                Self::push_unsupported_diagnostic(&mut diagnostics, "recursive CTEs");
+            }
+
+            if matches!(target, DialectType::TSQL | DialectType::Fabric)
+                && Self::node_has_lateral(node)
+            {
+                Self::push_unsupported_diagnostic(&mut diagnostics, "LATERAL joins and subqueries");
+            }
+
+            if !Self::target_supports_remaining_unnest(target) && Self::node_is_unnest(node) {
+                Self::push_unsupported_diagnostic(&mut diagnostics, "UNNEST");
+            }
+
+            if !Self::target_supports_remaining_explode(target) && Self::node_is_explode(node) {
+                Self::push_unsupported_diagnostic(&mut diagnostics, "EXPLODE");
+            }
+
+            if Self::target_lacks_array_agg(target) && Self::node_is_array_agg(node) {
+                Self::push_unsupported_diagnostic(&mut diagnostics, "ARRAY_AGG");
+            }
+
+            if matches!(source, DialectType::PostgreSQL | DialectType::CockroachDB)
+                && !matches!(target, DialectType::PostgreSQL | DialectType::CockroachDB)
+            {
+                if Self::node_is_function_named(node, "JSONB_BUILD_OBJECT") {
+                    Self::push_unsupported_diagnostic(
+                        &mut diagnostics,
+                        "PostgreSQL JSONB_BUILD_OBJECT",
+                    );
+                }
+                if Self::node_is_function_named(node, "TO_TSVECTOR") {
+                    Self::push_unsupported_diagnostic(&mut diagnostics, "PostgreSQL TO_TSVECTOR");
+                }
+            }
+
+            if opts.unsupported_level == UnsupportedLevel::Immediate && !diagnostics.is_empty() {
+                break;
+            }
+        }
+
+        if diagnostics.is_empty() {
+            return Ok(());
+        }
+
+        let limit = if opts.unsupported_level == UnsupportedLevel::Immediate {
+            1
+        } else {
+            opts.max_unsupported.max(1)
+        };
+        let mut messages = diagnostics.iter().take(limit).cloned().collect::<Vec<_>>();
+        if diagnostics.len() > limit {
+            messages.push(format!("... and {} more", diagnostics.len() - limit));
+        }
+
+        Err(crate::error::Error::unsupported(
+            messages.join("; "),
+            target.to_string(),
+        ))
+    }
+
+    fn push_unsupported_diagnostic(diagnostics: &mut Vec<String>, message: &str) {
+        if !diagnostics.iter().any(|existing| existing == message) {
+            diagnostics.push(message.to_string());
+        }
+    }
+
+    fn node_has_recursive_with(expr: &Expression) -> bool {
+        fn recursive(with: &Option<With>) -> bool {
+            with.as_ref().is_some_and(|with| with.recursive)
+        }
+
+        match expr {
+            Expression::With(with) => with.recursive,
+            Expression::Select(select) => recursive(&select.with),
+            Expression::Union(union) => recursive(&union.with),
+            Expression::Intersect(intersect) => recursive(&intersect.with),
+            Expression::Except(except) => recursive(&except.with),
+            Expression::Pivot(pivot) => recursive(&pivot.with),
+            Expression::Insert(insert) => recursive(&insert.with),
+            Expression::Update(update) => recursive(&update.with),
+            Expression::Delete(delete) => recursive(&delete.with),
+            _ => false,
+        }
+    }
+
+    fn node_has_lateral(expr: &Expression) -> bool {
+        fn joins_have_lateral(joins: &[Join]) -> bool {
+            joins.iter().any(|join| {
+                matches!(
+                    join.kind,
+                    crate::expressions::JoinKind::Lateral
+                        | crate::expressions::JoinKind::LeftLateral
+                )
+            })
+        }
+
+        match expr {
+            Expression::Subquery(subquery) => subquery.lateral,
+            Expression::Lateral(_) | Expression::LateralView(_) => true,
+            Expression::Join(join) => matches!(
+                join.kind,
+                crate::expressions::JoinKind::Lateral | crate::expressions::JoinKind::LeftLateral
+            ),
+            Expression::Select(select) => {
+                !select.lateral_views.is_empty() || joins_have_lateral(&select.joins)
+            }
+            Expression::JoinedTable(joined) => {
+                !joined.lateral_views.is_empty() || joins_have_lateral(&joined.joins)
+            }
+            Expression::Update(update) => {
+                joins_have_lateral(&update.table_joins) || joins_have_lateral(&update.from_joins)
+            }
+            _ => false,
+        }
+    }
+
+    fn target_supports_remaining_unnest(target: DialectType) -> bool {
+        matches!(
+            target,
+            DialectType::PostgreSQL
+                | DialectType::BigQuery
+                | DialectType::DuckDB
+                | DialectType::Presto
+                | DialectType::Trino
+                | DialectType::Athena
+        )
+    }
+
+    fn target_supports_remaining_explode(target: DialectType) -> bool {
+        matches!(
+            target,
+            DialectType::Spark | DialectType::Databricks | DialectType::Hive
+        )
+    }
+
+    fn target_lacks_array_agg(target: DialectType) -> bool {
+        matches!(
+            target,
+            DialectType::Fabric
+                | DialectType::TSQL
+                | DialectType::MySQL
+                | DialectType::SQLite
+                | DialectType::Oracle
+        )
+    }
+
+    fn node_is_unnest(expr: &Expression) -> bool {
+        matches!(expr, Expression::Unnest(_)) || Self::node_is_function_named(expr, "UNNEST")
+    }
+
+    fn node_is_explode(expr: &Expression) -> bool {
+        matches!(expr, Expression::Explode(_) | Expression::ExplodeOuter(_))
+            || Self::node_is_function_named(expr, "EXPLODE")
+            || Self::node_is_function_named(expr, "EXPLODE_OUTER")
+    }
+
+    fn node_is_array_agg(expr: &Expression) -> bool {
+        matches!(expr, Expression::ArrayAgg(_)) || Self::node_is_function_named(expr, "ARRAY_AGG")
+    }
+
+    fn node_is_function_named(expr: &Expression, name: &str) -> bool {
+        match expr {
+            Expression::Function(function) => function.name.eq_ignore_ascii_case(name),
+            Expression::AggregateFunction(function) => function.name.eq_ignore_ascii_case(name),
+            _ => false,
+        }
+    }
+
     fn rewrite_boolean_values_for_tsql(expr: Expression) -> Result<Expression> {
         match expr {
             Expression::Select(select) => Self::rewrite_boolean_values_in_tsql_select(select),

{polyglot_sql-0.4.4 → polyglot_sql-0.5.1}/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
     }