polyglot-sql 0.8.0__tar.gz → 0.9.0__tar.gz

{polyglot_sql-0.8.0 → polyglot_sql-0.9.0}/Cargo.lock

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

{polyglot_sql-0.8.0 → polyglot_sql-0.9.0}/Cargo.toml

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

{polyglot_sql-0.8.0 → polyglot_sql-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.8.0
+Version: 0.9.0
 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.0/crates/polyglot-sql-python → polyglot_sql-0.9.0}/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.0 → polyglot_sql-0.9.0}/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.0" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.9.0" }
 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.0", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.9.0", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.8.0 → polyglot_sql-0.9.0}/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.0", default-features = false }
+polyglot-sql = { version = "0.9.0", default-features = false }
 ```
 
 ```toml

{polyglot_sql-0.8.0 → polyglot_sql-0.9.0}/crates/polyglot-sql/src/ast_transforms.rs

@@ -9,6 +9,7 @@
 
 use std::collections::{HashMap, HashSet};
 
+use crate::builder::engine;
 use crate::expressions::*;
 use crate::traversal::ExpressionWalk;
 
@@ -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.