polyglot-sql 0.1.14__tar.gz → 0.2.0__tar.gz

{polyglot_sql-0.1.14 → polyglot_sql-0.2.0}/Cargo.lock

@@ -587,7 +587,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.1.14"
+version = "0.2.0"
 dependencies = [
  "criterion",
  "once_cell",
@@ -602,7 +602,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.1.14"
+version = "0.2.0"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -612,11 +612,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.1.14"
+version = "0.2.0"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.1.14"
+version = "0.2.0"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -627,7 +627,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.1.14"
+version = "0.2.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.1.14 → polyglot_sql-0.2.0}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.1.14"
+version = "0.2.0"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]
@@ -40,6 +40,12 @@ codegen-units = 1   # Better optimization
 panic = "abort"     # Smaller binary
 strip = true        # Strip symbols
 
+[profile.bench]
+inherits = "release"
+opt-level = 3
+lto = true
+codegen-units = 1
+
 [profile.ffi_release]
 inherits = "release"
 panic = "unwind"

{polyglot_sql-0.1.14 → polyglot_sql-0.2.0}/PKG-INFO

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

{polyglot_sql-0.1.14 → polyglot_sql-0.2.0}/crates/polyglot-sql/Cargo.toml

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

{polyglot_sql-0.1.14 → polyglot_sql-0.2.0}/crates/polyglot-sql/src/builder.rs

@@ -135,7 +135,7 @@ fn builder_table_ref(name: &str) -> TableRef {
 /// ```
 pub fn col(name: &str) -> Expr {
     if let Some((table, column)) = name.rsplit_once('.') {
-        Expr(Expression::Column(Column {
+        Expr(Expression::boxed_column(Column {
             name: builder_identifier(column),
             table: Some(builder_identifier(table)),
             join_mark: false,
@@ -144,7 +144,7 @@ pub fn col(name: &str) -> Expr {
             inferred_type: None,
         }))
     } else {
-        Expr(Expression::Column(Column {
+        Expr(Expression::boxed_column(Column {
             name: builder_identifier(name),
             table: None,
             join_mark: false,
@@ -206,7 +206,7 @@ pub fn boolean(value: bool) -> Expr {
 /// assert_eq!(t.to_sql(), "my_schema.users");
 /// ```
 pub fn table(name: &str) -> Expr {
-    Expr(Expression::Table(builder_table_ref(name)))
+    Expr(Expression::Table(Box::new(builder_table_ref(name))))
 }
 
 /// Create a SQL function call expression.
@@ -782,7 +782,7 @@ where
 pub fn from(table_name: &str) -> SelectBuilder {
     let mut builder = SelectBuilder::new();
     builder.select.from = Some(From {
-        expressions: vec![Expression::Table(builder_table_ref(table_name))],
+        expressions: vec![Expression::Table(Box::new(builder_table_ref(table_name)))],
     });
     builder
 }
@@ -1231,7 +1231,7 @@ impl SelectBuilder {
     /// Set the FROM clause to reference the given table by name.
     pub fn from(mut self, table_name: &str) -> Self {
         self.select.from = Some(From {
-            expressions: vec![Expression::Table(builder_table_ref(table_name))],
+            expressions: vec![Expression::Table(Box::new(builder_table_ref(table_name)))],
         });
         self
     }
@@ -1251,7 +1251,7 @@ impl SelectBuilder {
     pub fn join(mut self, table_name: &str, on: Expr) -> Self {
         self.select.joins.push(Join {
             kind: JoinKind::Inner,
-            this: Expression::Table(builder_table_ref(table_name)),
+            this: Expression::Table(Box::new(builder_table_ref(table_name))),
             on: Some(on.0),
             using: Vec::new(),
             use_inner_keyword: false,
@@ -1271,7 +1271,7 @@ impl SelectBuilder {
     pub fn left_join(mut self, table_name: &str, on: Expr) -> Self {
         self.select.joins.push(Join {
             kind: JoinKind::Left,
-            this: Expression::Table(builder_table_ref(table_name)),
+            this: Expression::Table(Box::new(builder_table_ref(table_name))),
             on: Some(on.0),
             using: Vec::new(),
             use_inner_keyword: false,
@@ -1404,7 +1404,7 @@ impl SelectBuilder {
     /// Set the LIMIT clause to restrict the result set to `count` rows.
     pub fn limit(mut self, count: usize) -> Self {
         self.select.limit = Some(Limit {
-            this: Expression::Literal(Literal::Number(count.to_string())),
+            this: Expression::Literal(Box::new(Literal::Number(count.to_string()))),
             percent: false,
             comments: Vec::new(),
         });
@@ -1414,7 +1414,7 @@ impl SelectBuilder {
     /// Set the OFFSET clause to skip the first `count` rows.
     pub fn offset(mut self, count: usize) -> Self {
         self.select.offset = Some(Offset {
-            this: Expression::Literal(Literal::Number(count.to_string())),
+            this: Expression::Literal(Box::new(Literal::Number(count.to_string()))),
             rows: None,
         });
         self
@@ -1439,7 +1439,7 @@ impl SelectBuilder {
     pub fn right_join(mut self, table_name: &str, on: Expr) -> Self {
         self.select.joins.push(Join {
             kind: JoinKind::Right,
-            this: Expression::Table(builder_table_ref(table_name)),
+            this: Expression::Table(Box::new(builder_table_ref(table_name))),
             on: Some(on.0),
             using: Vec::new(),
             use_inner_keyword: false,
@@ -1459,7 +1459,7 @@ impl SelectBuilder {
     pub fn cross_join(mut self, table_name: &str) -> Self {
         self.select.joins.push(Join {
             kind: JoinKind::Cross,
-            this: Expression::Table(builder_table_ref(table_name)),
+            this: Expression::Table(Box::new(builder_table_ref(table_name))),
             on: None,
             using: Vec::new(),
             use_inner_keyword: false,
@@ -1785,7 +1785,7 @@ impl UpdateBuilder {
     /// This allows joining against other tables within the UPDATE statement.
     pub fn from(mut self, table_name: &str) -> Self {
         self.update.from_clause = Some(From {
-            expressions: vec![Expression::Table(builder_table_ref(table_name))],
+            expressions: vec![Expression::Table(Box::new(builder_table_ref(table_name)))],
         });
         self
     }
@@ -2051,17 +2051,17 @@ impl SetOpBuilder {
 
     /// Restrict the combined set operation result to `count` rows.
     pub fn limit(mut self, count: usize) -> Self {
-        self.limit = Some(Box::new(Expression::Literal(Literal::Number(
+        self.limit = Some(Box::new(Expression::Literal(Box::new(Literal::Number(
             count.to_string(),
-        ))));
+        )))));
         self
     }
 
     /// Skip the first `count` rows from the combined set operation result.
     pub fn offset(mut self, count: usize) -> Self {
-        self.offset = Some(Box::new(Expression::Literal(Literal::Number(
+        self.offset = Some(Box::new(Expression::Literal(Box::new(Literal::Number(
             count.to_string(),
-        ))));
+        )))));
         self
     }
 
@@ -2328,42 +2328,42 @@ pub trait IntoLiteral {
 impl IntoLiteral for &str {
     /// Produce a SQL string literal (e.g. `'hello'`).
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Literal::String(self.to_string())))
+        Expr(Expression::Literal(Box::new(Literal::String(self.to_string()))))
     }
 }
 
 impl IntoLiteral for String {
     /// Produce a SQL string literal from an owned string.
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Literal::String(self)))
+        Expr(Expression::Literal(Box::new(Literal::String(self))))
     }
 }
 
 impl IntoLiteral for i64 {
     /// Produce a SQL numeric literal from a 64-bit integer.
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Literal::Number(self.to_string())))
+        Expr(Expression::Literal(Box::new(Literal::Number(self.to_string()))))
     }
 }
 
 impl IntoLiteral for i32 {
     /// Produce a SQL numeric literal from a 32-bit integer.
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Literal::Number(self.to_string())))
+        Expr(Expression::Literal(Box::new(Literal::Number(self.to_string()))))
     }
 }
 
 impl IntoLiteral for usize {
     /// Produce a SQL numeric literal from a `usize`.
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Literal::Number(self.to_string())))
+        Expr(Expression::Literal(Box::new(Literal::Number(self.to_string()))))
     }
 }
 
 impl IntoLiteral for f64 {
     /// Produce a SQL numeric literal from a 64-bit float.
     fn into_literal(self) -> Expr {
-        Expr(Expression::Literal(Literal::Number(self.to_string())))
+        Expr(Expression::Literal(Box::new(Literal::Number(self.to_string()))))
     }
 }
 
@@ -2412,7 +2412,7 @@ fn binary_op(left: Expression, right: Expression) -> BinaryOp {
 /// ```
 pub fn merge_into(target: &str) -> MergeBuilder {
     MergeBuilder {
-        target: Expression::Table(builder_table_ref(target)),
+        target: Expression::Table(Box::new(builder_table_ref(target))),
         using: None,
         on: None,
         whens: Vec::new(),
@@ -2432,7 +2432,7 @@ pub struct MergeBuilder {
 impl MergeBuilder {
     /// Set the source table and ON join condition.
     pub fn using(mut self, source: &str, on: Expr) -> Self {
-        self.using = Some(Expression::Table(builder_table_ref(source)));
+        self.using = Some(Expression::Table(Box::new(builder_table_ref(source))));
         self.on = Some(on.0);
         self
     }
@@ -2443,7 +2443,7 @@ impl MergeBuilder {
             .into_iter()
             .map(|(col_name, val)| {
                 Expression::Eq(Box::new(BinaryOp {
-                    left: Expression::Column(Column {
+                    left: Expression::boxed_column(Column {
                         name: builder_identifier(col_name),
                         table: None,
                         join_mark: false,
@@ -2491,7 +2491,7 @@ impl MergeBuilder {
             .into_iter()
             .map(|(col_name, val)| {
                 Expression::Eq(Box::new(BinaryOp {
-                    left: Expression::Column(Column {
+                    left: Expression::boxed_column(Column {
                         name: builder_identifier(col_name),
                         table: None,
                         join_mark: false,
@@ -2552,7 +2552,7 @@ impl MergeBuilder {
         let col_exprs: Vec<Expression> = columns
             .iter()
             .map(|c| {
-                Expression::Column(Column {
+                Expression::boxed_column(Column {
                     name: builder_identifier(c),
                     table: None,
                     join_mark: false,

{polyglot_sql-0.1.14 → polyglot_sql-0.2.0}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -523,8 +523,9 @@ impl DialectImpl for BigQueryDialect {
             Expression::Split(f) => {
                 // Check if delimiter is empty or a placeholder - add default comma
                 let delimiter = match &f.delimiter {
-                    Expression::Literal(Literal::String(s)) if s.is_empty() => {
-                        Expression::Literal(Literal::String(",".to_string()))
+                    Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(s) if s.is_empty()) => {
+                        let Literal::String(_) = lit.as_ref() else { unreachable!() };
+                        Expression::Literal(Box::new(Literal::String(",".to_string())))
                     }
                     _ => f.delimiter,
                 };
@@ -598,13 +599,13 @@ impl DialectImpl for BigQueryDialect {
                     if let Some(ref mut group_by) = select.group_by {
                         for grouped in group_by.expressions.iter_mut() {
                             // Skip numeric indices (already aliased)
-                            if matches!(grouped, Expression::Literal(Literal::Number(_))) {
+                            if matches!(grouped, Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Number(_))) {
                                 continue;
                             }
                             // Check if this GROUP BY expression matches a SELECT alias
                             for (expr, alias_ident) in &aliases {
                                 if grouped == expr {
-                                    *grouped = Expression::Column(Column {
+                                    *grouped = Expression::boxed_column(Column {
                                         name: alias_ident.clone(),
                                         table: None,
                                         join_mark: false,
@@ -642,7 +643,7 @@ impl DialectImpl for BigQueryDialect {
                     trailing_comments: Vec::new(),
                     inferred_type: None,
                 }));
-                let col_ref = Expression::Column(Column {
+                let col_ref = Expression::boxed_column(Column {
                     name: Identifier::new("_col"),
                     table: None,
                     join_mark: false,
@@ -661,7 +662,7 @@ impl DialectImpl for BigQueryDialect {
                     })),
                 };
                 let inner_select = Expression::Select(Box::new(Select {
-                    expressions: vec![Expression::Literal(Literal::Number("1".to_string()))],
+                    expressions: vec![Expression::Literal(Box::new(Literal::Number("1".to_string())))],
                     from: Some(From {
                         expressions: vec![aliased_unnest],
                     }),
@@ -716,15 +717,16 @@ impl DialectImpl for BigQueryDialect {
             // JSONExtract with variant_extract (Snowflake colon syntax) -> JSON_EXTRACT
             Expression::JSONExtract(e) if e.variant_extract.is_some() => {
                 let path = match *e.expression {
-                    Expression::Literal(Literal::String(s)) => {
+                    Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(_)) => {
+                        let Literal::String(s) = lit.as_ref() else { unreachable!() };
                         let normalized = if s.starts_with('$') {
-                            s
+                            s.clone()
                         } else if s.starts_with('[') {
                             format!("${}", s)
                         } else {
                             format!("$.{}", s)
                         };
-                        Expression::Literal(Literal::String(normalized))
+                        Expression::Literal(Box::new(Literal::String(normalized)))
                     }
                     other => other,
                 };
@@ -1191,7 +1193,7 @@ impl BigQueryDialect {
             // SPLIT(foo) -> SPLIT(foo, ',')
             "SPLIT" if f.args.len() == 1 => {
                 let mut args = f.args;
-                args.push(Expression::Literal(Literal::String(",".to_string())));
+                args.push(Expression::Literal(Box::new(Literal::String(",".to_string()))));
                 Ok(Expression::Split(Box::new(SplitFunc {
                     this: args.remove(0),
                     delimiter: args.remove(0),
@@ -1296,7 +1298,8 @@ impl BigQueryDialect {
                 let this = args.remove(0);
                 let path = args.remove(0);
                 let json_path = match &path {
-                    Expression::Literal(Literal::String(s)) => {
+                    Expression::Literal(lit) if matches!(lit.as_ref(), Literal::String(_)) => {
+                        let Literal::String(s) = lit.as_ref() else { unreachable!() };
                         let normalized = if s.starts_with('$') {
                             s.clone()
                         } else if s.starts_with('[') {
@@ -1304,7 +1307,7 @@ impl BigQueryDialect {
                         } else {
                             format!("$.{}", s)
                         };
-                        Expression::Literal(Literal::String(normalized))
+                        Expression::Literal(Box::new(Literal::String(normalized)))
                     }
                     _ => path,
                 };
@@ -1378,9 +1381,11 @@ impl BigQueryDialect {
             .map(|(i, arg)| {
                 // Only transform the first argument (the format string)
                 if i == 0 {
-                    if let Expression::Literal(Literal::String(s)) = arg {
-                        let normalized = self.normalize_time_format(&s);
-                        return Expression::Literal(Literal::String(normalized));
+                    if let Expression::Literal(ref lit) = arg {
+                        if let Literal::String(s) = lit.as_ref() {
+                            let normalized = self.normalize_time_format(&s);
+                            return Expression::Literal(Box::new(Literal::String(normalized)));
+                        }
                     }
                 }
                 arg

{polyglot_sql-0.1.14 → polyglot_sql-0.2.0}/crates/polyglot-sql/src/dialects/clickhouse.rs

@@ -40,6 +40,8 @@ impl DialectImpl for ClickHouseDialect {
         // ClickHouse supports 0xDEADBEEF hex integer literals
         config.hex_number_strings = true;
         config.hex_string_is_integer_type = true;
+        // ClickHouse allows underscores as digit separators in numeric literals
+        config.numbers_can_be_underscore_separated = true;
         config
     }
 

{polyglot_sql-0.1.14 → polyglot_sql-0.2.0}/crates/polyglot-sql/src/dialects/databricks.rs

@@ -149,10 +149,11 @@ impl DialectImpl for DatabricksDialect {
             Expression::DateSub(f) => {
                 // Convert string literals to numbers (interval values are often stored as strings)
                 let val = match f.interval {
-                    Expression::Literal(crate::expressions::Literal::String(s))
-                        if s.parse::<i64>().is_ok() =>
+                    Expression::Literal(lit) if matches!(lit.as_ref(), crate::expressions::Literal::String(s) if s.parse::<i64>().is_ok())
+                        =>
                     {
-                        Expression::Literal(crate::expressions::Literal::Number(s))
+                        let crate::expressions::Literal::String(s) = lit.as_ref() else { unreachable!() };
+                        Expression::Literal(Box::new(crate::expressions::Literal::Number(s.clone())))
                     }
                     other => other,
                 };
@@ -431,9 +432,8 @@ impl DatabricksDialect {
                 if f.args.len() == 2 {
                     let is_simple_number = matches!(
                         &f.args[1],
-                        Expression::Literal(crate::expressions::Literal::Number(_))
-                            | Expression::Neg(_)
-                    );
+                        Expression::Literal(lit) if matches!(lit.as_ref(), crate::expressions::Literal::Number(_))
+                    ) || matches!(&f.args[1], Expression::Neg(_));
                     if is_simple_number {
                         // Keep as DATE_ADD(date, num_days)
                         Ok(Expression::Function(Box::new(Function::new(
@@ -515,7 +515,8 @@ impl DatabricksDialect {
 
                 // Extract and strip the $. prefix from the path
                 let path_expr = match &path_arg {
-                    Expression::Literal(crate::expressions::Literal::String(s)) => {
+                    Expression::Literal(lit) if matches!(lit.as_ref(), crate::expressions::Literal::String(_)) => {
+                        let crate::expressions::Literal::String(s) = lit.as_ref() else { unreachable!() };
                         // Strip leading '$.' if present
                         let stripped = if s.starts_with("$.") {
                             &s[2..]
@@ -524,9 +525,9 @@ impl DatabricksDialect {
                         } else {
                             s.as_str()
                         };
-                        Expression::Literal(crate::expressions::Literal::String(
+                        Expression::Literal(Box::new(crate::expressions::Literal::String(
                             stripped.to_string(),
-                        ))
+                        )))
                     }
                     _ => path_arg,
                 };
@@ -817,10 +818,11 @@ impl DatabricksDialect {
         // Check if the inner expression is a typed literal
         match &c.this {
             // TIMESTAMP 'value'::TYPE -> CAST(CAST('value' AS TYPE) AS TIMESTAMP)
-            Expression::Literal(Literal::Timestamp(value)) => {
+            Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Timestamp(_)) => {
+                let Literal::Timestamp(value) = lit.as_ref() else { unreachable!() };
                 // Create inner cast: CAST('value' AS target_type)
                 let inner_cast = Expression::Cast(Box::new(Cast {
-                    this: Expression::Literal(Literal::String(value.clone())),
+                    this: Expression::Literal(Box::new(Literal::String(value.clone()))),
                     to: c.to,
                     trailing_comments: Vec::new(),
                     double_colon_syntax: false,
@@ -843,9 +845,10 @@ impl DatabricksDialect {
                 })))
             }
             // DATE 'value'::TYPE -> CAST(CAST('value' AS TYPE) AS DATE)
-            Expression::Literal(Literal::Date(value)) => {
+            Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Date(_)) => {
+                let Literal::Date(value) = lit.as_ref() else { unreachable!() };
                 let inner_cast = Expression::Cast(Box::new(Cast {
-                    this: Expression::Literal(Literal::String(value.clone())),
+                    this: Expression::Literal(Box::new(Literal::String(value.clone()))),
                     to: c.to,
                     trailing_comments: Vec::new(),
                     double_colon_syntax: false,
@@ -864,9 +867,10 @@ impl DatabricksDialect {
                 })))
             }
             // TIME 'value'::TYPE -> CAST(CAST('value' AS TYPE) AS TIME)
-            Expression::Literal(Literal::Time(value)) => {
+            Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Time(_)) => {
+                let Literal::Time(value) = lit.as_ref() else { unreachable!() };
                 let inner_cast = Expression::Cast(Box::new(Cast {
-                    this: Expression::Literal(Literal::String(value.clone())),
+                    this: Expression::Literal(Box::new(Literal::String(value.clone()))),
                     to: c.to,
                     trailing_comments: Vec::new(),
                     double_colon_syntax: false,

{polyglot_sql-0.1.14 → polyglot_sql-0.2.0}/crates/polyglot-sql/src/dialects/datafusion.rs

@@ -113,9 +113,9 @@ impl DataFusionDialect {
             // SQUARE(x) → POWER(x, 2)
             "SQUARE" => {
                 let mut args = f.args;
-                args.push(Expression::Literal(crate::expressions::Literal::Number(
+                args.push(Expression::Literal(Box::new(crate::expressions::Literal::Number(
                     "2".to_string(),
-                )));
+                ))));
                 Ok(Expression::Function(Box::new(Function::new(
                     "power".to_string(),
                     args,