polyglot-sql 0.8.1__tar.gz → 0.9.1__tar.gz

{polyglot_sql-0.8.1 → polyglot_sql-0.9.1}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.8.1"
+version = "0.9.1"
 dependencies = [
  "criterion",
  "once_cell",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.8.1"
+version = "0.9.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -632,7 +632,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.8.1"
+version = "0.9.1"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -642,11 +642,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.8.1"
+version = "0.9.1"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.8.1"
+version = "0.9.1"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -657,7 +657,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.8.1"
+version = "0.9.1"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.8.1 → polyglot_sql-0.9.1}/Cargo.toml

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

{polyglot_sql-0.8.1 → polyglot_sql-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.8.1
+Version: 0.9.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -68,6 +68,38 @@ polyglot_sql.parse_one("VARCHAR(255)", dialect="duckdb", into=polyglot_sql.DataT
 polyglot_sql.format_sql("SELECT a,b FROM t WHERE x=1", dialect="postgres")
 ```
 
+### SQLGlot-Compatible Builders
+
+The common SQLGlot builder surface is available directly from
+`polyglot_sql`. Builders return normal Polyglot expression objects and are
+immutable: each chained call returns a new expression.
+
+```python
+query = (
+    polyglot_sql.select("customer_id", "COUNT(*) AS orders")
+    .from_("orders")
+    .where("status = 'complete'")
+    .group_by("customer_id")
+    .order_by("orders DESC")
+    .limit(10)
+)
+
+query.sql("postgres")
+# "SELECT customer_id, COUNT(*) AS orders FROM orders WHERE status = 'complete' GROUP BY customer_id ORDER BY orders DESC LIMIT 10"
+
+active = polyglot_sql.column("status").eq("active")
+active.sql()
+# "status = 'active'"
+```
+
+The shared builder feature set also includes named aggregate/string/math/date
+helpers, all join and set-operation variants, named windows, lateral views,
+hints, row locks, CTAS, `CASE`, `INSERT`, `UPDATE`, `DELETE`, and conditional
+`MERGE` actions. Repeated clauses append by default; pass `append=False` to
+replace one. Advanced parser options, mutable `copy=False` behavior, and the
+complete SQLGlot expression catalog are not included. Polyglot expressions
+remain the native AST type; SQLGlot is not a runtime dependency.
+
 ```python
 ast = polyglot_sql.parse_one("SELECT id FROM a UNION ALL SELECT id FROM b")
 order_expr = polyglot_sql.parse_one("SELECT id").args["expressions"][0]

{polyglot_sql-0.8.1/crates/polyglot-sql-python → polyglot_sql-0.9.1}/README.md

@@ -41,6 +41,38 @@ polyglot_sql.parse_one("VARCHAR(255)", dialect="duckdb", into=polyglot_sql.DataT
 polyglot_sql.format_sql("SELECT a,b FROM t WHERE x=1", dialect="postgres")
 ```
 
+### SQLGlot-Compatible Builders
+
+The common SQLGlot builder surface is available directly from
+`polyglot_sql`. Builders return normal Polyglot expression objects and are
+immutable: each chained call returns a new expression.
+
+```python
+query = (
+    polyglot_sql.select("customer_id", "COUNT(*) AS orders")
+    .from_("orders")
+    .where("status = 'complete'")
+    .group_by("customer_id")
+    .order_by("orders DESC")
+    .limit(10)
+)
+
+query.sql("postgres")
+# "SELECT customer_id, COUNT(*) AS orders FROM orders WHERE status = 'complete' GROUP BY customer_id ORDER BY orders DESC LIMIT 10"
+
+active = polyglot_sql.column("status").eq("active")
+active.sql()
+# "status = 'active'"
+```
+
+The shared builder feature set also includes named aggregate/string/math/date
+helpers, all join and set-operation variants, named windows, lateral views,
+hints, row locks, CTAS, `CASE`, `INSERT`, `UPDATE`, `DELETE`, and conditional
+`MERGE` actions. Repeated clauses append by default; pass `append=False` to
+replace one. Advanced parser options, mutable `copy=False` behavior, and the
+complete SQLGlot expression catalog are not included. Polyglot expressions
+remain the native AST type; SQLGlot is not a runtime dependency.
+
 ```python
 ast = polyglot_sql.parse_one("SELECT id FROM a UNION ALL SELECT id FROM b")
 order_expr = polyglot_sql.parse_one("SELECT id").args["expressions"][0]

{polyglot_sql-0.8.1 → polyglot_sql-0.9.1}/crates/polyglot-sql/Cargo.toml

@@ -100,14 +100,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.8.1" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.9.1" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.8.1", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.9.1", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.8.1 → polyglot_sql-0.9.1}/crates/polyglot-sql/README.md

@@ -25,7 +25,7 @@ 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.8.1", default-features = false }
+polyglot-sql = { version = "0.9.1", default-features = false }
 ```
 
 ```toml

{polyglot_sql-0.8.1 → polyglot_sql-0.9.1}/crates/polyglot-sql/src/ast_transforms.rs

@@ -9,8 +9,9 @@
 
 use std::collections::{HashMap, HashSet};
 
+use crate::builder::engine;
 use crate::expressions::*;
-use crate::traversal::ExpressionWalk;
+use crate::traversal::{is_aggregate, ExpressionWalk};
 
 /// Apply a bottom-up transformation to every node in the tree.
 /// Wraps `crate::traversal::transform` with a simpler signature for this module.
@@ -28,12 +29,9 @@ fn xform<F: Fn(Expression) -> Expression>(expr: Expression, fun: F) -> Expressio
 /// If `expr` is a `Select`, the given `columns` are appended to its expression list.
 /// Non-SELECT expressions are returned unchanged.
 pub fn add_select_columns(expr: Expression, columns: Vec<Expression>) -> Expression {
-    if let Expression::Select(mut sel) = expr {
-        sel.expressions.extend(columns);
-        Expression::Select(sel)
-    } else {
-        expr
-    }
+    let mut expression = expr;
+    let _ = engine::append_select(&mut expression, columns, true);
+    expression
 }
 
 /// Remove columns from the SELECT list where `predicate` returns `true`.
@@ -51,12 +49,9 @@ pub fn remove_select_columns<F: Fn(&Expression) -> bool>(
 
 /// Set or remove the DISTINCT flag on a SELECT.
 pub fn set_distinct(expr: Expression, distinct: bool) -> Expression {
-    if let Expression::Select(mut sel) = expr {
-        sel.distinct = distinct;
-        Expression::Select(sel)
-    } else {
-        expr
-    }
+    let mut expression = expr;
+    let _ = engine::apply_distinct(&mut expression, distinct);
+    expression
 }
 
 // ---------------------------------------------------------------------------
@@ -69,6 +64,14 @@ pub fn set_distinct(expr: Expression, distinct: bool) -> Expression {
 /// existing one using AND (default) or OR (when `use_or` is `true`).
 /// If there is no WHERE clause, one is created.
 pub fn add_where(expr: Expression, condition: Expression, use_or: bool) -> Expression {
+    if !use_or {
+        if !matches!(expr, Expression::Select(_)) {
+            return expr;
+        }
+        let mut expression = expr;
+        let _ = engine::apply_where(&mut expression, condition, true);
+        return expression;
+    }
     if let Expression::Select(mut sel) = expr {
         sel.where_clause = Some(match sel.where_clause.take() {
             Some(existing) => {
@@ -108,29 +111,9 @@ pub fn set_limit(expr: Expression, limit: usize) -> Expression {
 
 /// Set the LIMIT on a SELECT or set operation using an expression.
 pub fn set_limit_expr(expr: Expression, limit: Expression) -> Expression {
-    match expr {
-        Expression::Select(mut sel) => {
-            sel.limit = Some(Limit {
-                this: limit,
-                percent: false,
-                comments: Vec::new(),
-            });
-            Expression::Select(sel)
-        }
-        Expression::Union(mut union) => {
-            union.limit = Some(Box::new(limit));
-            Expression::Union(union)
-        }
-        Expression::Intersect(mut intersect) => {
-            intersect.limit = Some(Box::new(limit));
-            Expression::Intersect(intersect)
-        }
-        Expression::Except(mut except) => {
-            except.limit = Some(Box::new(limit));
-            Expression::Except(except)
-        }
-        other => other,
-    }
+    let mut expression = expr;
+    let _ = engine::apply_limit(&mut expression, limit);
+    expression
 }
 
 /// Set the OFFSET on a SELECT or set operation.
@@ -140,28 +123,9 @@ pub fn set_offset(expr: Expression, offset: usize) -> Expression {
 
 /// Set the OFFSET on a SELECT or set operation using an expression.
 pub fn set_offset_expr(expr: Expression, offset: Expression) -> Expression {
-    match expr {
-        Expression::Select(mut sel) => {
-            sel.offset = Some(Offset {
-                this: offset,
-                rows: None,
-            });
-            Expression::Select(sel)
-        }
-        Expression::Union(mut union) => {
-            union.offset = Some(Box::new(offset));
-            Expression::Union(union)
-        }
-        Expression::Intersect(mut intersect) => {
-            intersect.offset = Some(Box::new(offset));
-            Expression::Intersect(intersect)
-        }
-        Expression::Except(mut except) => {
-            except.offset = Some(Box::new(offset));
-            Expression::Except(except)
-        }
-        other => other,
-    }
+    let mut expression = expr;
+    let _ = engine::apply_offset(&mut expression, offset);
+    expression
 }
 
 /// Set the ORDER BY clause on a SELECT or set operation.
@@ -169,38 +133,10 @@ pub fn set_offset_expr(expr: Expression, offset: Expression) -> Expression {
 /// Bare expressions are normalized to ascending order expressions. Existing
 /// `Ordered` expressions preserve their direction and null-ordering metadata.
 pub fn set_order_by(expr: Expression, expressions: Vec<Expression>) -> Expression {
-    let order_by = OrderBy {
-        expressions: expressions.into_iter().map(normalize_ordered).collect(),
-        siblings: false,
-        comments: Vec::new(),
-    };
-
-    match expr {
-        Expression::Select(mut sel) => {
-            sel.order_by = Some(order_by);
-            Expression::Select(sel)
-        }
-        Expression::Union(mut union) => {
-            union.order_by = Some(order_by);
-            Expression::Union(union)
-        }
-        Expression::Intersect(mut intersect) => {
-            intersect.order_by = Some(order_by);
-            Expression::Intersect(intersect)
-        }
-        Expression::Except(mut except) => {
-            except.order_by = Some(order_by);
-            Expression::Except(except)
-        }
-        other => other,
-    }
-}
-
-fn normalize_ordered(expression: Expression) -> Ordered {
-    match expression {
-        Expression::Ordered(ordered) => *ordered,
-        other => Ordered::asc(other),
-    }
+    let mut expression = expr;
+    let values = expressions.into_iter().map(engine::ordered).collect();
+    let _ = engine::apply_order_by(&mut expression, values, false);
+    expression
 }
 
 /// Remove both LIMIT and OFFSET from a SELECT.
@@ -400,6 +336,26 @@ pub fn get_output_column_names(expr: &Expression) -> Vec<String> {
     output_column_names_from_query(expr)
 }
 
+/// Collect projected output column names using dialect-specific set-operation
+/// alignment rules.
+///
+/// This differs from [`get_output_column_names`] only for name-aligned set
+/// operations. When an output shape is not statically knowable (for example an
+/// unresolved wildcard), it preserves the existing leftmost-branch behavior.
+pub fn get_output_column_names_for_dialect(
+    expr: &Expression,
+    dialect: Option<crate::dialects::DialectType>,
+) -> Vec<String> {
+    crate::set_operation::query_output_identifiers(expr, dialect)
+        .map(|identifiers| {
+            identifiers
+                .into_iter()
+                .map(|identifier| identifier.name)
+                .collect()
+        })
+        .unwrap_or_else(|_| output_column_names_from_query(expr))
+}
+
 fn output_column_names_from_query(expr: &Expression) -> Vec<String> {
     match expr {
         Expression::Select(select) => select_output_column_names(select),
@@ -604,22 +560,7 @@ pub fn get_subqueries(expr: &Expression) -> Vec<&Expression> {
 /// Includes typed aggregates (`Count`, `Sum`, `Avg`, `Min`, `Max`, etc.)
 /// and generic `AggregateFunction` nodes.
 pub fn get_aggregate_functions(expr: &Expression) -> Vec<&Expression> {
-    expr.find_all(|e| {
-        matches!(
-            e,
-            Expression::AggregateFunction(_)
-                | Expression::Count(_)
-                | Expression::Sum(_)
-                | Expression::Avg(_)
-                | Expression::Min(_)
-                | Expression::Max(_)
-                | Expression::ApproxDistinct(_)
-                | Expression::ArrayAgg(_)
-                | Expression::GroupConcat(_)
-                | Expression::StringAgg(_)
-                | Expression::ListAgg(_)
-        )
-    })
+    expr.find_all(is_aggregate)
 }
 
 /// Collect all window function nodes in the expression tree.
@@ -759,6 +700,37 @@ mod tests {
         assert_eq!(names, vec!["c1".to_string(), "c2".to_string()]);
     }
 
+    #[test]
+    fn test_get_output_column_names_uses_dialect_by_name_layout() {
+        for dialect in [
+            crate::dialects::DialectType::DuckDB,
+            crate::dialects::DialectType::Snowflake,
+        ] {
+            let expr = crate::parse_one(
+                "SELECT 1 AS left_value UNION ALL BY NAME SELECT 2 AS right_value",
+                dialect,
+            )
+            .expect("parse");
+            assert_eq!(
+                get_output_column_names_for_dialect(&expr, Some(dialect)),
+                vec!["left_value", "right_value"]
+            );
+        }
+
+        let expr = crate::parse_one(
+            "SELECT 1 AS a, 2 AS b UNION ALL BY NAME SELECT 3 AS b, 4 AS a",
+            crate::dialects::DialectType::BigQuery,
+        )
+        .expect("parse");
+        assert_eq!(
+            get_output_column_names_for_dialect(
+                &expr,
+                Some(crate::dialects::DialectType::BigQuery),
+            ),
+            vec!["a", "b"]
+        );
+    }
+
     #[test]
     fn test_get_column_names_union_still_returns_all_references() {
         let expr =
@@ -915,12 +887,14 @@ mod tests {
 
     #[test]
     fn test_get_aggregate_functions() {
-        let expr = parse_one("SELECT COUNT(*), SUM(x) FROM t");
+        let expr = crate::parse_one(
+            "SELECT COUNT_IF(numeric_value > 0), MEDIAN(numeric_value), FIRST(numeric_value) FROM source_table",
+            crate::dialects::DialectType::DuckDB,
+        )
+        .unwrap();
         let aggs = get_aggregate_functions(&expr);
-        assert!(
-            aggs.len() >= 2,
-            "Expected at least 2 aggregates, got {}",
-            aggs.len()
-        );
+        let aggregate_types: Vec<_> = aggs.iter().map(|agg| agg.variant_name()).collect();
+
+        assert_eq!(aggregate_types, vec!["count_if", "median", "first"]);
     }
 }